/home/coin/SVN-release/OS-2.4.2/Bonmin/src/Algorithms/QuadCuts/BonTMINLPLinObj.cpp

Go to the documentation of this file.
00001 // (C) Copyright International Business Machines Corporation 2007
00002 // All Rights Reserved.
00003 //
00004 // Authors :
00005 // Pierre Bonami, International Business Machines Corporation
00006 //
00007 // Date : 08/16/2007
00008 
00009 #include "BonTMINLPLinObj.hpp"
00010 
00011 using namespace Ipopt;
00012 
00013 namespace Bonmin{
00015    TMINLPLinObj::TMINLPLinObj():
00016    tminlp_(NULL), m_(0), n_(0), 
00017    nnz_jac_(0)
00018    {}
00019 
00020    void 
00021    TMINLPLinObj::gutsOfDestructor(){
00022      tminlp_ = NULL;
00023    }
00024  
00025    
00026    TMINLPLinObj::~TMINLPLinObj(){
00027    gutsOfDestructor();}
00028 
00029 
00030   void
00031    TMINLPLinObj::setTminlp(SmartPtr<TMINLP> tminlp){
00032       gutsOfDestructor();
00033       tminlp_ = tminlp;
00034       int n,m, nnz_jac, nnz_h;
00035       Ipopt::TNLP::IndexStyleEnum index_style;
00036       tminlp_->get_nlp_info(n, m , nnz_jac, nnz_h, index_style);
00037       offset_ = index_style == Ipopt::TNLP::FORTRAN_STYLE;
00038       n_ = n+1;
00039       m_ = m+1;
00040       nnz_jac_ = nnz_jac + n + 1;
00041   }
00042 
00043    bool 
00044    TMINLPLinObj::get_nlp_info(Index& n, Index& m, Index& nnz_jac_g,
00045                                          Index& nnz_h_lag, 
00046                                          Ipopt::TNLP::IndexStyleEnum& index_style){
00047      assert(IsValid(tminlp_));
00048 
00049      bool return_value = 
00050           tminlp_->get_nlp_info(n,m,nnz_jac_g, nnz_h_lag,index_style);
00051      m = m_;
00052      n = n_;
00053      nnz_jac_g = nnz_jac_;
00054      return return_value;
00055    }
00056    
00057 
00058    bool 
00059    TMINLPLinObj::get_scaling_parameters(Number& obj_scaling,
00060                                                    bool& use_x_scaling, Index n,
00061                                                    Number* x_scaling,
00062                                                    bool& use_g_scaling, Index m,
00063                                                    Number* g_scaling){
00064      assert(IsValid(tminlp_));
00065      assert(m == m_);
00066 
00067 
00068      if(g_scaling && use_g_scaling)
00069        g_scaling[0] = 1.;
00070      if(x_scaling && use_x_scaling)
00071        x_scaling[n - 1] = 1.;
00072      obj_scaling = 1.;
00073      double dummy = 1.;
00074      double * mod_obj_scaling = &dummy;
00075      if(use_g_scaling && g_scaling){
00076        mod_obj_scaling = g_scaling;}
00077      return tminlp_->get_scaling_parameters(*mod_obj_scaling, use_x_scaling, n - 1, x_scaling,
00078                                                          use_g_scaling, m - 1, g_scaling + 1);
00079    }
00080 
00081 
00082 
00083 
00084 
00085    bool
00086    TMINLPLinObj::get_constraints_linearity(Index m, 
00087                                            Ipopt::TNLP::LinearityType* const_types){
00088       assert(IsValid(tminlp_));
00089       assert(m == m_ );
00090               const_types[0] = Ipopt::TNLP::NON_LINEAR;
00091         return tminlp_->get_constraints_linearity(m-1, const_types +1);}
00092 
00093    bool
00094    TMINLPLinObj::get_bounds_info(Index n, Number* x_l, Number* x_u,
00095         Index m, Number* g_l, Number* g_u){
00096      assert(IsValid(tminlp_));
00097      assert(m == m_);
00098      assert(n == n_);
00099 
00100      x_l[n-1] = -DBL_MAX;
00101      x_u[n-1] = DBL_MAX;
00102     
00103      g_l[0] = -DBL_MAX;
00104      g_u[0] = 0.;
00105      return tminlp_->get_bounds_info(n - 1, x_l, x_u, m_ - 1,
00106                                      g_l +1, g_u + 1);
00107    }
00108 
00109    bool
00110    TMINLPLinObj::get_starting_point(Index n, bool init_x, Number* x,
00111                                                 bool init_z, Number* z_L, Number* z_U,
00112                                                 Index m, bool init_lambda,
00113                                                 Number* lambda){
00114      assert(IsValid(tminlp_));
00115      assert(m == m_);
00116 
00117      bool return_value = tminlp_->get_starting_point(n - 1, init_x, x, init_z, z_L, z_U,
00118                                             m - 1, init_lambda, lambda + 1);
00119      tminlp_->eval_f(n-1, x, true, x[n-1]);
00120      if(init_lambda && lambda != NULL)
00121        lambda[0] = 0;
00122      return return_value;
00123    }
00124    
00125 
00126    bool
00127    TMINLPLinObj::eval_g(Index n, const Number* x, bool new_x,
00128                                    Index m, Number* g){
00129      assert(IsValid(tminlp_));
00130      assert(m == m_);
00131      assert(n == n_);
00132 
00133      bool ret_val =  tminlp_->eval_f(n - 1, x, new_x, g[0]);
00134      g[0] -= x[n -1];
00135      return ret_val && tminlp_->eval_g(n - 1, x, false, m - 1, g+1);
00136    }
00137 
00138    bool
00139    TMINLPLinObj::eval_jac_g(Index n, const Number* x, bool new_x,
00140         Index m, Index nele_jac, Index* iRow,
00141         Index *jCol, Number* values){
00142      assert(IsValid(tminlp_));
00143      assert(m == m_);
00144      assert(n == n_);
00145      assert(nele_jac == nnz_jac_);
00146      bool ret_val = true;
00147      if(values == NULL)
00148      {
00149        for(int i = 0 ; i < n_ ; i++){
00150          iRow[i] = offset_; jCol[i] = i + offset_;}
00151        bool ret_val = tminlp_->eval_jac_g(n -1, x, new_x, m_ -1, nnz_jac_ - n_, iRow + n_, jCol + n_, NULL);
00152        for(int i = n_ ; i < nnz_jac_ ; i++){//shift by 1
00153          iRow[i]++;}
00154        return ret_val;
00155      }
00156      else {
00157        ret_val &= tminlp_->eval_grad_f(n-1, x, new_x, values);
00158        values[n-1] = -1;
00159        ret_val &= tminlp_->eval_jac_g(n - 1, x, false, m - 1, nele_jac - n_, NULL, NULL, values + n);
00160      }
00161      return ret_val;
00162    }
00163 
00164    bool
00165    TMINLPLinObj::eval_h(Index n, const Number* x, bool new_x,
00166         Number obj_factor, Index m, const Number* lambda,
00167         bool new_lambda, Index nele_hess,
00168         Index* iRow, Index* jCol, Number* values){
00169      assert(IsValid(tminlp_));
00170      assert(m == m_);
00171      assert(n == n_);
00172      return tminlp_->eval_h(n_ - 1, x, new_x, (lambda != NULL)? lambda[0]: 1., m_ - 1, (lambda != NULL)? lambda + 1: NULL, new_lambda,
00173                                   nele_hess, iRow, jCol, values);
00174     }
00175 
00176 
00177    bool
00178    TMINLPLinObj:: eval_gi(Index n, const Number* x, bool new_x,
00179                          Index i, Number& gi){
00180      assert(IsValid(tminlp_));
00181      assert(i < m_);
00182      assert(n == n_);
00183      if(i == 0){
00184       bool ret_val = tminlp_->eval_f(n-1, x, new_x, gi);
00185       gi -= x[n -1];
00186       return ret_val;}
00187       else
00188       return tminlp_->eval_gi(n-1, x, new_x, i - 1, gi);
00189    }
00190 
00191    bool
00192    TMINLPLinObj::eval_grad_gi(Index n, const Number* x, bool new_x,
00193                               Index i, Index& nele_grad_gi, Index* jCol,
00194                               Number* values){
00195      assert(IsValid(tminlp_));
00196      assert(i < m_);
00197      assert(n == n_);
00198      if(i == 0){
00199       if(jCol != NULL){
00200         for(int i = 0 ; i < n ; i++) jCol[i] = i + offset_;
00201       }
00202       bool ret_val= tminlp_->eval_grad_f(n-1, x, new_x, values);
00203       values[n-1] = -1;
00204       return ret_val;}
00205       else
00206         return tminlp_->eval_grad_gi(n - 1, x, new_x, i - 1, nele_grad_gi,
00207                         jCol, values);
00208    }
00209 
00210 
00211 }/* Ends namespace Bonmin.*/

Generated on Wed Nov 30 03:03:54 2011 by  doxygen 1.4.7