00001
00002
00003
00004
00005
00006
00007
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++){
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 }