/build/buildd/coinor-ipopt-3.10.1/Ipopt/examples/ScalableProblems/MittelmannDistCntrlDiri.hpp
Go to the documentation of this file.
00001 // Copyright (C) 2005, 2006 International Business Machines and others.
00002 // All Rights Reserved.
00003 // This code is published under the Eclipse Public License.
00004 //
00005 // $Id: MittelmannDistCntrlDiri.hpp 2005 2011-06-06 12:55:16Z stefan $
00006 //
00007 // Authors:  Andreas Waechter           IBM    2005-10-18
00008 //                  based on MyNLP.hpp
00009 
00010 #ifndef __MITTELMANNDISTRCNTRLDIRI_HPP__
00011 #define __MITTELMANNDISTRCNTRLDIRI_HPP__
00012 
00013 #include "IpTNLP.hpp"
00014 #include "RegisteredTNLP.hpp"
00015 
00016 #ifdef HAVE_CONFIG_H
00017 #include "config.h"
00018 #else
00019 #include "configall_system.h"
00020 #endif
00021 
00022 #ifdef HAVE_CMATH
00023 # include <cmath>
00024 #else
00025 # ifdef HAVE_MATH_H
00026 #  include <math.h>
00027 # else
00028 #  error "don't have header file for math"
00029 # endif
00030 #endif
00031 
00032 #ifdef HAVE_CSTDIO
00033 # include <cstdio>
00034 #else
00035 # ifdef HAVE_STDIO_H
00036 #  include <stdio.h>
00037 # else
00038 #  error "don't have header file for stdio"
00039 # endif
00040 #endif
00041 
00042 using namespace Ipopt;
00043 
00050 class MittelmannDistCntrlDiriBase : public RegisteredTNLP
00051 {
00052 public:
00055   MittelmannDistCntrlDiriBase();
00056 
00058   virtual ~MittelmannDistCntrlDiriBase();
00059 
00063   virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g,
00064                             Index& nnz_h_lag, IndexStyleEnum& index_style);
00065 
00067   virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u,
00068                                Index m, Number* g_l, Number* g_u);
00069 
00071   virtual bool get_starting_point(Index n, bool init_x, Number* x,
00072                                   bool init_z, Number* z_L, Number* z_U,
00073                                   Index m, bool init_lambda,
00074                                   Number* lambda);
00075 
00077   virtual bool eval_f(Index n, const Number* x, bool new_x, Number& obj_value);
00078 
00080   virtual bool eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f);
00081 
00083   virtual bool eval_g(Index n, const Number* x, bool new_x, Index m, Number* g);
00084 
00089   virtual bool eval_jac_g(Index n, const Number* x, bool new_x,
00090                           Index m, Index nele_jac, Index* iRow, Index *jCol,
00091                           Number* values);
00092 
00097   virtual bool eval_h(Index n, const Number* x, bool new_x,
00098                       Number obj_factor, Index m, const Number* lambda,
00099                       bool new_lambda, Index nele_hess, Index* iRow,
00100                       Index* jCol, Number* values);
00101 
00103 
00105   virtual bool get_scaling_parameters(Number& obj_scaling,
00106                                       bool& use_x_scaling, Index n,
00107                                       Number* x_scaling,
00108                                       bool& use_g_scaling, Index m,
00109                                       Number* g_scaling);
00110 
00115   virtual void finalize_solution(SolverReturn status,
00116                                  Index n, const Number* x, const Number* z_L, const Number* z_U,
00117                                  Index m, const Number* g, const Number* lambda,
00118                                  Number obj_value,
00119                                  const IpoptData* ip_data,
00120                                  IpoptCalculatedQuantities* ip_cq);
00122 
00123 protected:
00127   void SetBaseParameters(Index N, Number alpha, Number lb_y,
00128                          Number ub_y, Number lb_u, Number ub_u,
00129                          Number u_init);
00130 
00134   virtual Number y_d_cont(Number x1, Number x2) const =0;
00136   virtual Number d_cont(Number x1, Number x2, Number y, Number u) const =0;
00138   virtual Number d_cont_dy(Number x1, Number x2, Number y, Number u) const =0;
00140   virtual Number d_cont_du(Number x1, Number x2, Number y, Number u) const =0;
00142   virtual Number d_cont_dydy(Number x1, Number x2, Number y, Number u) const =0;
00144 
00145 private:
00157   MittelmannDistCntrlDiriBase(const MittelmannDistCntrlDiriBase&);
00158   MittelmannDistCntrlDiriBase& operator=(const MittelmannDistCntrlDiriBase&);
00160 
00164   Index N_;
00166   Number h_;
00168   Number hh_;
00170   Number lb_y_;
00172   Number ub_y_;
00174   Number lb_u_;
00176   Number ub_u_;
00178   Number u_init_;
00181   Number alpha_;
00183   Number* y_d_;
00185 
00190   inline Index y_index(Index i, Index j) const
00191   {
00192     return j + (N_+2)*i;
00193   }
00196   inline Index u_index(Index i, Index j) const
00197   {
00198     return (N_+2)*(N_+2) + (j-1) + (N_)*(i-1);
00199   }
00202   inline Index pde_index(Index i, Index j) const
00203   {
00204     return (j-1) + N_*(i-1);
00205   }
00207   inline Number x1_grid(Index i) const
00208   {
00209     return h_*(Number)i;
00210   }
00212   inline Number x2_grid(Index i) const
00213   {
00214     return h_*(Number)i;
00215   }
00217 };
00218 
00220 class MittelmannDistCntrlDiri1 : public MittelmannDistCntrlDiriBase
00221 {
00222 public:
00223   MittelmannDistCntrlDiri1()
00224   {}
00225 
00226   virtual ~MittelmannDistCntrlDiri1()
00227   {}
00228 
00229   virtual bool InitializeProblem(Index N)
00230   {
00231     if (N<1) {
00232       printf("N has to be at least 1.");
00233       return false;
00234     }
00235     Number alpha = 0.001;
00236     Number lb_y = -1e20;
00237     Number ub_y = 0.185;
00238     Number lb_u = 1.5;
00239     Number ub_u = 4.5;
00240     Number u_init = (ub_u+lb_u)/2.;
00241 
00242     SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, u_init);
00243     return true;
00244   }
00245 protected:
00247   virtual Number y_d_cont(Number x1, Number x2)  const
00248   {
00249     return 1. + 2.*(x1*(x1-1.)+x2*(x2-1.));
00250   }
00252   virtual Number d_cont(Number x1, Number x2, Number y, Number u)  const
00253   {
00254     return pow(y,3) - y - u;
00255   }
00257   virtual Number d_cont_dy(Number x1, Number x2, Number y, Number u)  const
00258   {
00259     return 3.*y*y - 1.;
00260   }
00262   virtual Number d_cont_du(Number x1, Number x2, Number y, Number u)  const
00263   {
00264     return -1.;
00265   }
00267   virtual Number d_cont_dydy(Number x1, Number x2, Number y, Number u)  const
00268   {
00269     return 6.*y;
00270   }
00271 private:
00274   MittelmannDistCntrlDiri1(const MittelmannDistCntrlDiri1&);
00275   MittelmannDistCntrlDiri1& operator=(const MittelmannDistCntrlDiri1&);
00277 };
00278 
00280 class MittelmannDistCntrlDiri2 : public MittelmannDistCntrlDiriBase
00281 {
00282 public:
00283   MittelmannDistCntrlDiri2()
00284   {}
00285   virtual ~MittelmannDistCntrlDiri2()
00286   {}
00287   virtual bool InitializeProblem(Index N)
00288   {
00289     if (N<1) {
00290       printf("N has to be at least 1.");
00291       return false;
00292     }
00293     Number alpha = 0.;
00294     Number lb_y = -1e20;
00295     Number ub_y = 0.185;
00296     Number lb_u = 1.5;
00297     Number ub_u = 4.5;
00298     Number u_init = (ub_u+lb_u)/2.;
00299 
00300     SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, u_init);
00301     return true;
00302   }
00303 protected:
00305   virtual Number y_d_cont(Number x1, Number x2)  const
00306   {
00307     return 1. + 2.*(x1*(x1-1.)+x2*(x2-1.));
00308   }
00310   virtual Number d_cont(Number x1, Number x2, Number y, Number u)  const
00311   {
00312     return pow(y,3) - y - u;
00313   }
00315   virtual Number d_cont_dy(Number x1, Number x2, Number y, Number u)  const
00316   {
00317     return 3.*y*y - 1.;
00318   }
00320   virtual Number d_cont_du(Number x1, Number x2, Number y, Number u)  const
00321   {
00322     return -1.;
00323   }
00325   virtual Number d_cont_dydy(Number x1, Number x2, Number y, Number u)  const
00326   {
00327     return 6.*y;
00328   }
00329 private:
00332   MittelmannDistCntrlDiri2(const MittelmannDistCntrlDiri2&);
00333   MittelmannDistCntrlDiri2& operator=(const MittelmannDistCntrlDiri2&);
00335 };
00336 
00338 class MittelmannDistCntrlDiri3 : public MittelmannDistCntrlDiriBase
00339 {
00340 public:
00341   MittelmannDistCntrlDiri3()
00342       :
00343       pi_(4.*atan(1.))
00344   {}
00345   virtual ~MittelmannDistCntrlDiri3()
00346   {}
00347   virtual bool InitializeProblem(Index N)
00348   {
00349     if (N<1) {
00350       printf("N has to be at least 1.");
00351       return false;
00352     }
00353     Number alpha = 0.001;
00354     Number lb_y = -1e20;
00355     Number ub_y = 0.11;
00356     Number lb_u = -5;
00357     Number ub_u = 5.;
00358     Number u_init = (ub_u+lb_u)/2.;
00359 
00360     SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, u_init);
00361     return true;
00362   }
00363 protected:
00365   virtual Number y_d_cont(Number x1, Number x2)  const
00366   {
00367     return sin(2.*pi_*x1)*sin(2.*pi_*x2);
00368   }
00370   virtual Number d_cont(Number x1, Number x2, Number y, Number u)  const
00371   {
00372     return -exp(y) - u;
00373   }
00375   virtual Number d_cont_dy(Number x1, Number x2, Number y, Number u)  const
00376   {
00377     return -exp(y);
00378   }
00380   virtual Number d_cont_du(Number x1, Number x2, Number y, Number u)  const
00381   {
00382     return -1.;
00383   }
00385   virtual Number d_cont_dydy(Number x1, Number x2, Number y, Number u)  const
00386   {
00387     return -exp(y);
00388   }
00389 private:
00392   MittelmannDistCntrlDiri3(const MittelmannDistCntrlDiri3&);
00393   MittelmannDistCntrlDiri3& operator=(const MittelmannDistCntrlDiri3&);
00395 
00396   const Number pi_;
00397 };
00398 
00399 class MittelmannDistCntrlDiri3a : public MittelmannDistCntrlDiriBase
00400 {
00401 public:
00402   MittelmannDistCntrlDiri3a()
00403       :
00404       pi_(4.*atan(1.))
00405   {}
00406   virtual ~MittelmannDistCntrlDiri3a()
00407   {}
00408   virtual bool InitializeProblem(Index N)
00409   {
00410     if (N<1) {
00411       printf("N has to be at least 1.");
00412       return false;
00413     }
00414     Number alpha = 0.;
00415     Number lb_y = -1e20;
00416     Number ub_y = 0.11;
00417     Number lb_u = -5;
00418     Number ub_u = 5.;
00419     Number u_init = (ub_u+lb_u)/2.;
00420 
00421     SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, u_init);
00422     return true;
00423   }
00424 protected:
00426   virtual Number y_d_cont(Number x1, Number x2)  const
00427   {
00428     return sin(2.*pi_*x1)*sin(2.*pi_*x2);
00429   }
00431   virtual Number d_cont(Number x1, Number x2, Number y, Number u)  const
00432   {
00433     return -exp(y) - u;
00434   }
00436   virtual Number d_cont_dy(Number x1, Number x2, Number y, Number u)  const
00437   {
00438     return -exp(y);
00439   }
00441   virtual Number d_cont_du(Number x1, Number x2, Number y, Number u)  const
00442   {
00443     return -1.;
00444   }
00446   virtual Number d_cont_dydy(Number x1, Number x2, Number y, Number u)  const
00447   {
00448     return -exp(y);
00449   }
00450 private:
00453   MittelmannDistCntrlDiri3a(const MittelmannDistCntrlDiri3a&);
00454   MittelmannDistCntrlDiri3a& operator=(const MittelmannDistCntrlDiri3a&);
00456 
00457   const Number pi_;
00458 };
00459 
00460 #endif