/home/coin/SVN-release/Ipopt-3.9.0/Ipopt/examples/ScalableProblems/MittelmannBndryCntrlDiri.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 Common Public License.
00004 //
00005 // $Id: MittelmannBndryCntrlDiri.hpp 1707 2010-07-03 18:25:51Z stefan $
00006 //
00007 // Authors:  Andreas Waechter           IBM    2005-10-18
00008 //                  based on MyNLP.hpp
00009 
00010 #ifndef __MITTELMANNBNDRYCNTRLDIRI_HPP__
00011 #define __MITTELMANNBNDRYCNTRLDIRI_HPP__
00012 
00013 #include "RegisteredTNLP.hpp"
00014 
00015 #ifdef HAVE_CMATH
00016 # include <cmath>
00017 #else
00018 # ifdef HAVE_MATH_H
00019 #  include <math.h>
00020 # else
00021 #  error "don't have header file for math"
00022 # endif
00023 #endif
00024 
00025 #include <cstdio>
00026 
00027 using namespace Ipopt;
00028 
00038 class MittelmannBndryCntrlDiriBase : public RegisteredTNLP
00039 {
00040 public:
00042   MittelmannBndryCntrlDiriBase();
00043 
00045   virtual ~MittelmannBndryCntrlDiriBase();
00046 
00050   virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g,
00051                             Index& nnz_h_lag, IndexStyleEnum& index_style);
00052 
00054   virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u,
00055                                Index m, Number* g_l, Number* g_u);
00056 
00058   virtual bool get_starting_point(Index n, bool init_x, Number* x,
00059                                   bool init_z, Number* z_L, Number* z_U,
00060                                   Index m, bool init_lambda,
00061                                   Number* lambda);
00062 
00064   virtual bool eval_f(Index n, const Number* x, bool new_x, Number& obj_value);
00065 
00067   virtual bool eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f);
00068 
00070   virtual bool eval_g(Index n, const Number* x, bool new_x, Index m, Number* g);
00071 
00076   virtual bool eval_jac_g(Index n, const Number* x, bool new_x,
00077                           Index m, Index nele_jac, Index* iRow, Index *jCol,
00078                           Number* values);
00079 
00084   virtual bool eval_h(Index n, const Number* x, bool new_x,
00085                       Number obj_factor, Index m, const Number* lambda,
00086                       bool new_lambda, Index nele_hess, Index* iRow,
00087                       Index* jCol, Number* values);
00088 
00090 
00092   virtual bool get_scaling_parameters(Number& obj_scaling,
00093                                       bool& use_x_scaling, Index n,
00094                                       Number* x_scaling,
00095                                       bool& use_g_scaling, Index m,
00096                                       Number* g_scaling);
00097 
00102   virtual void finalize_solution(SolverReturn status,
00103                                  Index n, const Number* x, const Number* z_L, const Number* z_U,
00104                                  Index m, const Number* g, const Number* lambda,
00105                                  Number obj_valu,
00106                                  const IpoptData* ip_data,
00107                                  IpoptCalculatedQuantities* ip_cq);
00109 
00110 protected:
00114   void SetBaseParameters(Index N, Number alpha, Number lb_y,
00115                          Number ub_y, Number lb_u, Number ub_u,
00116                          Number d_const);
00117 
00121   virtual Number y_d_cont(Number x1, Number x2) const =0;
00123 
00124 private:
00136   MittelmannBndryCntrlDiriBase(const MittelmannBndryCntrlDiriBase&);
00137   MittelmannBndryCntrlDiriBase& operator=(const MittelmannBndryCntrlDiriBase&);
00139 
00143   Index N_;
00145   Number h_;
00147   Number hh_;
00149   Number lb_y_;
00151   Number ub_y_;
00153   Number lb_u_;
00155   Number ub_u_;
00157   Number d_const_;
00160   Number alpha_;
00162   Number* y_d_;
00164 
00169   inline Index y_index(Index i, Index j) const
00170   {
00171     return j + (N_+2)*i;
00172   }
00175   inline Index pde_index(Index i, Index j) const
00176   {
00177     return (j-1) + N_*(i-1);
00178   }
00180   inline Number x1_grid(Index i) const
00181   {
00182     return h_*(Number)i;
00183   }
00185   inline Number x2_grid(Index i) const
00186   {
00187     return h_*(Number)i;
00188   }
00190 };
00191 
00193 class MittelmannBndryCntrlDiri1 : public MittelmannBndryCntrlDiriBase
00194 {
00195 public:
00196   MittelmannBndryCntrlDiri1()
00197   {}
00198 
00199   virtual ~MittelmannBndryCntrlDiri1()
00200   {}
00201 
00202   virtual bool InitializeProblem(Index N)
00203   {
00204     if (N<1) {
00205       printf("N has to be at least 1.");
00206       return false;
00207     }
00208     Number alpha = 0.01;
00209     Number lb_y = -1e20;
00210     Number ub_y = 3.5;
00211     Number lb_u = 0.;
00212     Number ub_u = 10.;
00213     Number d_const = -20.;
00214     SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, d_const);
00215     return true;
00216   }
00217 protected:
00219   virtual Number y_d_cont(Number x1, Number x2)  const
00220   {
00221     return 3. + 5.*(x1*(x1-1.)*x2*(x2-1.));
00222   }
00223 private:
00226   MittelmannBndryCntrlDiri1(const MittelmannBndryCntrlDiri1&);
00227   MittelmannBndryCntrlDiri1& operator=(const MittelmannBndryCntrlDiri1&);
00229 };
00230 
00232 class MittelmannBndryCntrlDiri2 : public MittelmannBndryCntrlDiriBase
00233 {
00234 public:
00235   MittelmannBndryCntrlDiri2()
00236   {}
00237 
00238   virtual ~MittelmannBndryCntrlDiri2()
00239   {}
00240 
00241   virtual bool InitializeProblem(Index N)
00242   {
00243     if (N<1) {
00244       printf("N has to be at least 1.");
00245       return false;
00246     }
00247     Number alpha = 0.;
00248     Number lb_y = -1e20;
00249     Number ub_y = 3.5;
00250     Number lb_u = 0.;
00251     Number ub_u = 10.;
00252     Number d_const = -20.;
00253     SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, d_const);
00254     return true;
00255   }
00256 protected:
00258   virtual Number y_d_cont(Number x1, Number x2)  const
00259   {
00260     return 3. + 5.*(x1*(x1-1.)*x2*(x2-1.));
00261   }
00262 private:
00265   MittelmannBndryCntrlDiri2(const MittelmannBndryCntrlDiri2&);
00266   MittelmannBndryCntrlDiri2& operator=(const MittelmannBndryCntrlDiri2&);
00268 };
00269 
00271 class MittelmannBndryCntrlDiri3 : public MittelmannBndryCntrlDiriBase
00272 {
00273 public:
00274   MittelmannBndryCntrlDiri3()
00275   {}
00276 
00277   virtual ~MittelmannBndryCntrlDiri3()
00278   {}
00279 
00280   virtual bool InitializeProblem(Index N)
00281   {
00282     if (N<1) {
00283       printf("N has to be at least 1.");
00284       return false;
00285     }
00286     Number alpha = 0.01;
00287     Number lb_y = -1e20;
00288     Number ub_y = 3.2;
00289     Number lb_u = 1.6;
00290     Number ub_u = 2.3;
00291     Number d_const = -20.;
00292     SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, d_const);
00293     return true;
00294   }
00295 protected:
00297   virtual Number y_d_cont(Number x1, Number x2)  const
00298   {
00299     return 3. + 5.*(x1*(x1-1.)*x2*(x2-1.));
00300   }
00301 private:
00304   MittelmannBndryCntrlDiri3(const MittelmannBndryCntrlDiri3&);
00305   MittelmannBndryCntrlDiri3& operator=(const MittelmannBndryCntrlDiri3&);
00307 };
00308 
00310 class MittelmannBndryCntrlDiri4 : public MittelmannBndryCntrlDiriBase
00311 {
00312 public:
00313   MittelmannBndryCntrlDiri4()
00314   {}
00315 
00316   virtual ~MittelmannBndryCntrlDiri4()
00317   {}
00318 
00319   virtual bool InitializeProblem(Index N)
00320   {
00321     if (N<1) {
00322       printf("N has to be at least 1.");
00323       return false;
00324     }
00325     Number alpha = 0.;
00326     Number lb_y = -1e20;
00327     Number ub_y = 3.2;
00328     Number lb_u = 1.6;
00329     Number ub_u = 2.3;
00330     Number d_const = -20.;
00331     SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, d_const);
00332     return true;
00333   }
00334 protected:
00336   virtual Number y_d_cont(Number x1, Number x2)  const
00337   {
00338     return 3. + 5.*(x1*(x1-1.)*x2*(x2-1.));
00339   }
00340 private:
00343   MittelmannBndryCntrlDiri4(const MittelmannBndryCntrlDiri4&);
00344   MittelmannBndryCntrlDiri4& operator=(const MittelmannBndryCntrlDiri4&);
00346 };
00347 
00348 #endif

Generated on Sat Nov 6 03:10:30 2010 by  doxygen 1.4.7