/home/coin/SVN-release/Ipopt-3.9.2/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 1864 2010-12-22 19:21:02Z andreasw $
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_CMATH
00017 # include <cmath>
00018 #else
00019 # ifdef HAVE_MATH_H
00020 #  include <math.h>
00021 # else
00022 #  error "don't have header file for math"
00023 # endif
00024 #endif
00025 
00026 #include <cstdio>
00027 
00028 using namespace Ipopt;
00029 
00036 class MittelmannDistCntrlDiriBase : public RegisteredTNLP
00037 {
00038 public:
00041   MittelmannDistCntrlDiriBase();
00042 
00044   virtual ~MittelmannDistCntrlDiriBase();
00045 
00049   virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g,
00050                             Index& nnz_h_lag, IndexStyleEnum& index_style);
00051 
00053   virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u,
00054                                Index m, Number* g_l, Number* g_u);
00055 
00057   virtual bool get_starting_point(Index n, bool init_x, Number* x,
00058                                   bool init_z, Number* z_L, Number* z_U,
00059                                   Index m, bool init_lambda,
00060                                   Number* lambda);
00061 
00063   virtual bool eval_f(Index n, const Number* x, bool new_x, Number& obj_value);
00064 
00066   virtual bool eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f);
00067 
00069   virtual bool eval_g(Index n, const Number* x, bool new_x, Index m, Number* g);
00070 
00075   virtual bool eval_jac_g(Index n, const Number* x, bool new_x,
00076                           Index m, Index nele_jac, Index* iRow, Index *jCol,
00077                           Number* values);
00078 
00083   virtual bool eval_h(Index n, const Number* x, bool new_x,
00084                       Number obj_factor, Index m, const Number* lambda,
00085                       bool new_lambda, Index nele_hess, Index* iRow,
00086                       Index* jCol, Number* values);
00087 
00089 
00091   virtual bool get_scaling_parameters(Number& obj_scaling,
00092                                       bool& use_x_scaling, Index n,
00093                                       Number* x_scaling,
00094                                       bool& use_g_scaling, Index m,
00095                                       Number* g_scaling);
00096 
00101   virtual void finalize_solution(SolverReturn status,
00102                                  Index n, const Number* x, const Number* z_L, const Number* z_U,
00103                                  Index m, const Number* g, const Number* lambda,
00104                                  Number obj_value,
00105                                  const IpoptData* ip_data,
00106                                  IpoptCalculatedQuantities* ip_cq);
00108 
00109 protected:
00113   void SetBaseParameters(Index N, Number alpha, Number lb_y,
00114                          Number ub_y, Number lb_u, Number ub_u,
00115                          Number u_init);
00116 
00120   virtual Number y_d_cont(Number x1, Number x2) const =0;
00122   virtual Number d_cont(Number x1, Number x2, Number y, Number u) const =0;
00124   virtual Number d_cont_dy(Number x1, Number x2, Number y, Number u) const =0;
00126   virtual Number d_cont_du(Number x1, Number x2, Number y, Number u) const =0;
00128   virtual Number d_cont_dydy(Number x1, Number x2, Number y, Number u) const =0;
00130 
00131 private:
00143   MittelmannDistCntrlDiriBase(const MittelmannDistCntrlDiriBase&);
00144   MittelmannDistCntrlDiriBase& operator=(const MittelmannDistCntrlDiriBase&);
00146 
00150   Index N_;
00152   Number h_;
00154   Number hh_;
00156   Number lb_y_;
00158   Number ub_y_;
00160   Number lb_u_;
00162   Number ub_u_;
00164   Number u_init_;
00167   Number alpha_;
00169   Number* y_d_;
00171 
00176   inline Index y_index(Index i, Index j) const
00177   {
00178     return j + (N_+2)*i;
00179   }
00182   inline Index u_index(Index i, Index j) const
00183   {
00184     return (N_+2)*(N_+2) + (j-1) + (N_)*(i-1);
00185   }
00188   inline Index pde_index(Index i, Index j) const
00189   {
00190     return (j-1) + N_*(i-1);
00191   }
00193   inline Number x1_grid(Index i) const
00194   {
00195     return h_*(Number)i;
00196   }
00198   inline Number x2_grid(Index i) const
00199   {
00200     return h_*(Number)i;
00201   }
00203 };
00204 
00206 class MittelmannDistCntrlDiri1 : public MittelmannDistCntrlDiriBase
00207 {
00208 public:
00209   MittelmannDistCntrlDiri1()
00210   {}
00211 
00212   virtual ~MittelmannDistCntrlDiri1()
00213   {}
00214 
00215   virtual bool InitializeProblem(Index N)
00216   {
00217     if (N<1) {
00218       printf("N has to be at least 1.");
00219       return false;
00220     }
00221     Number alpha = 0.001;
00222     Number lb_y = -1e20;
00223     Number ub_y = 0.185;
00224     Number lb_u = 1.5;
00225     Number ub_u = 4.5;
00226     Number u_init = (ub_u+lb_u)/2.;
00227 
00228     SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, u_init);
00229     return true;
00230   }
00231 protected:
00233   virtual Number y_d_cont(Number x1, Number x2)  const
00234   {
00235     return 1. + 2.*(x1*(x1-1.)+x2*(x2-1.));
00236   }
00238   virtual Number d_cont(Number x1, Number x2, Number y, Number u)  const
00239   {
00240     return pow(y,3) - y - u;
00241   }
00243   virtual Number d_cont_dy(Number x1, Number x2, Number y, Number u)  const
00244   {
00245     return 3.*y*y - 1.;
00246   }
00248   virtual Number d_cont_du(Number x1, Number x2, Number y, Number u)  const
00249   {
00250     return -1.;
00251   }
00253   virtual Number d_cont_dydy(Number x1, Number x2, Number y, Number u)  const
00254   {
00255     return 6.*y;
00256   }
00257 private:
00260   MittelmannDistCntrlDiri1(const MittelmannDistCntrlDiri1&);
00261   MittelmannDistCntrlDiri1& operator=(const MittelmannDistCntrlDiri1&);
00263 };
00264 
00266 class MittelmannDistCntrlDiri2 : public MittelmannDistCntrlDiriBase
00267 {
00268 public:
00269   MittelmannDistCntrlDiri2()
00270   {}
00271   virtual ~MittelmannDistCntrlDiri2()
00272   {}
00273   virtual bool InitializeProblem(Index N)
00274   {
00275     if (N<1) {
00276       printf("N has to be at least 1.");
00277       return false;
00278     }
00279     Number alpha = 0.;
00280     Number lb_y = -1e20;
00281     Number ub_y = 0.185;
00282     Number lb_u = 1.5;
00283     Number ub_u = 4.5;
00284     Number u_init = (ub_u+lb_u)/2.;
00285 
00286     SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, u_init);
00287     return true;
00288   }
00289 protected:
00291   virtual Number y_d_cont(Number x1, Number x2)  const
00292   {
00293     return 1. + 2.*(x1*(x1-1.)+x2*(x2-1.));
00294   }
00296   virtual Number d_cont(Number x1, Number x2, Number y, Number u)  const
00297   {
00298     return pow(y,3) - y - u;
00299   }
00301   virtual Number d_cont_dy(Number x1, Number x2, Number y, Number u)  const
00302   {
00303     return 3.*y*y - 1.;
00304   }
00306   virtual Number d_cont_du(Number x1, Number x2, Number y, Number u)  const
00307   {
00308     return -1.;
00309   }
00311   virtual Number d_cont_dydy(Number x1, Number x2, Number y, Number u)  const
00312   {
00313     return 6.*y;
00314   }
00315 private:
00318   MittelmannDistCntrlDiri2(const MittelmannDistCntrlDiri2&);
00319   MittelmannDistCntrlDiri2& operator=(const MittelmannDistCntrlDiri2&);
00321 };
00322 
00324 class MittelmannDistCntrlDiri3 : public MittelmannDistCntrlDiriBase
00325 {
00326 public:
00327   MittelmannDistCntrlDiri3()
00328       :
00329       pi_(4.*atan(1.))
00330   {}
00331   virtual ~MittelmannDistCntrlDiri3()
00332   {}
00333   virtual bool InitializeProblem(Index N)
00334   {
00335     if (N<1) {
00336       printf("N has to be at least 1.");
00337       return false;
00338     }
00339     Number alpha = 0.001;
00340     Number lb_y = -1e20;
00341     Number ub_y = 0.11;
00342     Number lb_u = -5;
00343     Number ub_u = 5.;
00344     Number u_init = (ub_u+lb_u)/2.;
00345 
00346     SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, u_init);
00347     return true;
00348   }
00349 protected:
00351   virtual Number y_d_cont(Number x1, Number x2)  const
00352   {
00353     return sin(2.*pi_*x1)*sin(2.*pi_*x2);
00354   }
00356   virtual Number d_cont(Number x1, Number x2, Number y, Number u)  const
00357   {
00358     return -exp(y) - u;
00359   }
00361   virtual Number d_cont_dy(Number x1, Number x2, Number y, Number u)  const
00362   {
00363     return -exp(y);
00364   }
00366   virtual Number d_cont_du(Number x1, Number x2, Number y, Number u)  const
00367   {
00368     return -1.;
00369   }
00371   virtual Number d_cont_dydy(Number x1, Number x2, Number y, Number u)  const
00372   {
00373     return -exp(y);
00374   }
00375 private:
00378   MittelmannDistCntrlDiri3(const MittelmannDistCntrlDiri3&);
00379   MittelmannDistCntrlDiri3& operator=(const MittelmannDistCntrlDiri3&);
00381 
00382   const Number pi_;
00383 };
00384 
00385 class MittelmannDistCntrlDiri3a : public MittelmannDistCntrlDiriBase
00386 {
00387 public:
00388   MittelmannDistCntrlDiri3a()
00389       :
00390       pi_(4.*atan(1.))
00391   {}
00392   virtual ~MittelmannDistCntrlDiri3a()
00393   {}
00394   virtual bool InitializeProblem(Index N)
00395   {
00396     if (N<1) {
00397       printf("N has to be at least 1.");
00398       return false;
00399     }
00400     Number alpha = 0.;
00401     Number lb_y = -1e20;
00402     Number ub_y = 0.11;
00403     Number lb_u = -5;
00404     Number ub_u = 5.;
00405     Number u_init = (ub_u+lb_u)/2.;
00406 
00407     SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, u_init);
00408     return true;
00409   }
00410 protected:
00412   virtual Number y_d_cont(Number x1, Number x2)  const
00413   {
00414     return sin(2.*pi_*x1)*sin(2.*pi_*x2);
00415   }
00417   virtual Number d_cont(Number x1, Number x2, Number y, Number u)  const
00418   {
00419     return -exp(y) - u;
00420   }
00422   virtual Number d_cont_dy(Number x1, Number x2, Number y, Number u)  const
00423   {
00424     return -exp(y);
00425   }
00427   virtual Number d_cont_du(Number x1, Number x2, Number y, Number u)  const
00428   {
00429     return -1.;
00430   }
00432   virtual Number d_cont_dydy(Number x1, Number x2, Number y, Number u)  const
00433   {
00434     return -exp(y);
00435   }
00436 private:
00439   MittelmannDistCntrlDiri3a(const MittelmannDistCntrlDiri3a&);
00440   MittelmannDistCntrlDiri3a& operator=(const MittelmannDistCntrlDiri3a&);
00442 
00443   const Number pi_;
00444 };
00445 
00446 #endif

Generated on Thu Dec 23 03:09:10 2010 by  doxygen 1.4.7