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