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

Generated on Tue Mar 30 03:04:34 2010 by  doxygen 1.4.7