source: branches/dev/Algorithm/IpOrigIpoptNLP.cpp @ 416

Last change on this file since 416 was 416, checked in by andreasw, 14 years ago
  • revised handling of "acceptable level of accuracy" (now in ConvCheck?)
  • fixed uncaught evaluation error exceptions
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 20.3 KB
Line 
1// Copyright (C) 2004, International Business Machines and others.
2// All Rights Reserved.
3// This code is published under the Common Public License.
4//
5// $Id: IpOrigIpoptNLP.cpp 416 2005-07-29 19:11:41Z andreasw $
6//
7// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
8
9#include "IpOrigIpoptNLP.hpp"
10#ifdef OLD_C_HEADERS
11# include <math.h>
12#else
13# include <cmath>
14#endif
15
16namespace Ipopt
17{
18  DBG_SET_VERBOSITY(0);
19
20  DefineIpoptType(OrigIpoptNLP);
21
22  OrigIpoptNLP::OrigIpoptNLP(const SmartPtr<const Journalist>& jnlst,
23                             const SmartPtr<NLP>& nlp,
24                             const SmartPtr<NLPScalingObject>& nlp_scaling)
25      :
26      IpoptNLP(nlp_scaling),
27      jnlst_(jnlst),
28      nlp_(nlp),
29      f_cache_(1),
30      grad_f_cache_(1),
31      c_cache_(1),
32      jac_c_cache_(1),
33      d_cache_(1),
34      jac_d_cache_(1),
35      h_cache_(1),
36      f_evals_(0),
37      grad_f_evals_(0),
38      c_evals_(0),
39      jac_c_evals_(0),
40      d_evals_(0),
41      jac_d_evals_(0),
42      h_evals_(0),
43      initialized_(false)
44  {}
45
46  OrigIpoptNLP::~OrigIpoptNLP()
47  {}
48
49  void OrigIpoptNLP::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
50  {
51    roptions->AddLowerBoundedNumberOption(
52      "bound_relax_factor",
53      "Factor for initial relaxation of the bounds.",
54      0, false,
55      1e-8,
56      "Before start of the optimization, the bounds given by the user are "
57      "relaxed.  This option determines the factor by how much.  If it "
58      "is set to zero, then this option is disabled.  (See Eqn.(35) in "
59      "implmentation paper.)");
60  }
61
62  bool OrigIpoptNLP::Initialize(const Journalist& jnlst,
63                                const OptionsList& options,
64                                const std::string& prefix)
65  {
66    options.GetNumericValue("bound_relax_factor", bound_relax_factor_, prefix);
67
68    if (!nlp_->ProcessOptions(options, prefix)) {
69      return false;
70    }
71
72    initialized_ = true;
73    return IpoptNLP::Initialize(jnlst, options, prefix);
74  }
75
76  bool OrigIpoptNLP::InitializeStructures(SmartPtr<Vector>& x,
77                                          bool init_x,
78                                          SmartPtr<Vector>& y_c,
79                                          bool init_y_c,
80                                          SmartPtr<Vector>& y_d,
81                                          bool init_y_d,
82                                          SmartPtr<Vector>& z_L,
83                                          bool init_z_L,
84                                          SmartPtr<Vector>& z_U,
85                                          bool init_z_U,
86                                          SmartPtr<Vector>& v_L,
87                                          SmartPtr<Vector>& v_U
88                                         )
89  {
90    DBG_ASSERT(initialized_);
91
92    bool retValue = nlp_->GetSpaces(x_space_, c_space_, d_space_,
93                                    x_l_space_, px_l_space_,
94                                    x_u_space_, px_u_space_,
95                                    d_l_space_, pd_l_space_,
96                                    d_u_space_, pd_u_space_,
97                                    jac_c_space_, jac_d_space_,
98                                    h_space_);
99
100    if (!retValue) {
101      return false;
102    }
103
104    NLP_scaling()->DetermineScaling(x_space_,
105                                    c_space_, d_space_,
106                                    jac_c_space_, jac_d_space_,
107                                    h_space_,
108                                    scaled_jac_c_space_, scaled_jac_d_space_,
109                                    scaled_h_space_);
110
111    ASSERT_EXCEPTION(x_space_->Dim() >= c_space_->Dim(), TOO_FEW_DOF,
112                     "Too few degrees of freedom!");
113
114    // cannot have any null pointers, want zero length vectors
115    // instead of null - this will later need to be changed for _h;
116    retValue = (IsValid(x_space_) && IsValid(c_space_) && IsValid(d_space_)
117                && IsValid(x_l_space_) && IsValid(px_l_space_)
118                && IsValid(x_u_space_) && IsValid(px_u_space_)
119                && IsValid(d_u_space_) && IsValid(pd_u_space_)
120                && IsValid(d_l_space_) && IsValid(pd_l_space_)
121                && IsValid(jac_c_space_) && IsValid(jac_d_space_)
122                && IsValid(h_space_)
123                && IsValid(scaled_jac_c_space_) && IsValid(scaled_jac_d_space_)
124                && IsValid(scaled_h_space_));
125
126    DBG_ASSERT(retValue && "Model cannot return null vector or matrix prototypes or spaces,"
127               " please return zero length vectors instead");
128
129    // Create the bounds structures
130    SmartPtr<Vector> x_L = x_l_space_->MakeNew();
131    SmartPtr<Matrix> Px_L = px_l_space_->MakeNew();
132    SmartPtr<Vector> x_U = x_u_space_->MakeNew();
133    SmartPtr<Matrix> Px_U = px_u_space_->MakeNew();
134    SmartPtr<Vector> d_L = d_l_space_->MakeNew();
135    SmartPtr<Matrix> Pd_L = pd_l_space_->MakeNew();
136    SmartPtr<Vector> d_U = d_u_space_->MakeNew();
137    SmartPtr<Matrix> Pd_U = pd_u_space_->MakeNew();
138
139    retValue = nlp_->GetBoundsInformation(*Px_L, *x_L, *Px_U, *x_U,
140                                          *Pd_L, *d_L, *Pd_U, *d_U);
141
142    if (!retValue) {
143      return false;
144    }
145
146    relax_bounds(-bound_relax_factor_, *x_L);
147    relax_bounds( bound_relax_factor_, *x_U);
148    relax_bounds(-bound_relax_factor_, *d_L);
149    relax_bounds( bound_relax_factor_, *d_U);
150
151    x_L_ = ConstPtr(x_L);
152    Px_L_ = ConstPtr(Px_L);
153    x_U_ = ConstPtr(x_U);
154    Px_U_ = ConstPtr(Px_U);
155    d_L_ = ConstPtr(d_L);
156    Pd_L_ = ConstPtr(Pd_L);
157    d_U_ = ConstPtr(d_U);
158    Pd_U_ = ConstPtr(Pd_U);
159
160    // now create and store the scaled bounds
161    x_L_ = NLP_scaling()->apply_vector_scaling_x_LU(*Px_L_, x_L_, *x_space_);
162    x_U_ = NLP_scaling()->apply_vector_scaling_x_LU(*Px_U_, x_U_, *x_space_);
163    d_L_ = NLP_scaling()->apply_vector_scaling_d_LU(*Pd_L_, d_L_, *d_space_);
164    d_U_ = NLP_scaling()->apply_vector_scaling_d_LU(*Pd_U_, d_U_, *d_space_);
165
166    // Create the iterates structures
167    x = x_space_->MakeNew();
168    y_c = c_space_->MakeNew();
169    y_d = d_space_->MakeNew();
170    z_L = x_l_space_->MakeNew();
171    z_U = x_u_space_->MakeNew();
172    v_L = d_l_space_->MakeNew();
173    v_U = d_u_space_->MakeNew();
174
175    retValue = nlp_->GetStartingPoint(GetRawPtr(x), init_x,
176                                      GetRawPtr(y_c), init_y_c,
177                                      GetRawPtr(y_d), init_y_d,
178                                      GetRawPtr(z_L), init_z_L,
179                                      GetRawPtr(z_U), init_z_U);
180
181    if (!retValue) {
182      return false;
183    }
184
185    Number obj_scal = NLP_scaling()->apply_obj_scaling(1.);
186    if (init_x) {
187      if (NLP_scaling()->have_x_scaling()) {
188        x = NLP_scaling()->apply_vector_scaling_x_NonConst(ConstPtr(x));
189      }
190    }
191    if (init_y_c) {
192      if (NLP_scaling()->have_c_scaling()) {
193        y_c = NLP_scaling()->unapply_vector_scaling_c_NonConst(ConstPtr(y_c));
194      }
195      if (obj_scal!=1.) {
196        y_c->Scal(obj_scal);
197      }
198    }
199    if (init_y_d) {
200      if (NLP_scaling()->have_d_scaling()) {
201        y_d = NLP_scaling()->unapply_vector_scaling_d_NonConst(ConstPtr(y_d));
202      }
203      if (obj_scal!=1.) {
204        y_d->Scal(obj_scal);
205      }
206    }
207    if (init_z_L) {
208      if (NLP_scaling()->have_x_scaling()) {
209        z_L = NLP_scaling()->apply_vector_scaling_x_LU_NonConst(*Px_L_, ConstPtr(z_L), *x_space_);
210      }
211      if (obj_scal!=1.) {
212        z_L->Scal(obj_scal);
213      }
214    }
215    if (init_z_U) {
216      if (NLP_scaling()->have_x_scaling()) {
217        z_U = NLP_scaling()->apply_vector_scaling_x_LU_NonConst(*Px_U_, ConstPtr(z_U), *x_space_);
218      }
219      if (obj_scal!=1.) {
220        z_U->Scal(obj_scal);
221      }
222    }
223
224    return true;
225  }
226
227  void
228  OrigIpoptNLP::relax_bounds(Number bound_relax_factor, Vector& bounds)
229  {
230    DBG_START_METH("OrigIpoptNLP::relax_bounds", dbg_verbosity);
231    if (bound_relax_factor!=0.) {
232      SmartPtr<Vector> tmp = bounds.MakeNew();
233      tmp->Copy(bounds);
234      tmp->ElementWiseAbs();
235      SmartPtr<Vector> ones = bounds.MakeNew();
236      ones->Set(1.);
237      tmp->ElementWiseMax(*ones);
238      DBG_PRINT((1, "bound_relax_factor = %e", bound_relax_factor));
239      DBG_PRINT_VECTOR(2, "tmp", *tmp);
240      DBG_PRINT_VECTOR(2, "bounds before", bounds);
241      bounds.Axpy(bound_relax_factor, *tmp);
242      DBG_PRINT_VECTOR(2, "bounds after", bounds);
243    }
244  }
245
246  Number OrigIpoptNLP::f(const Vector& x)
247  {
248    DBG_START_METH("OrigIpoptNLP::f", dbg_verbosity);
249    Number ret = 0.0;
250    DBG_PRINT((2, "x.Tag = %d\n", x.GetTag()));
251    if (!f_cache_.GetCachedResult1Dep(ret, &x)) {
252      f_evals_++;
253      SmartPtr<const Vector> unscaled_x = NLP_scaling()->unapply_vector_scaling_x(&x);
254      bool success = nlp_->Eval_f(*unscaled_x, ret);
255      DBG_PRINT((1, "success = %d ret = %e\n", success, ret));
256      ASSERT_EXCEPTION(success && FiniteNumber(ret), Eval_Error,
257                       "Error evaluating the objective function");
258      ret = NLP_scaling()->apply_obj_scaling(ret);
259      f_cache_.AddCachedResult1Dep(ret, &x);
260    }
261
262    return ret;
263  }
264
265  SmartPtr<const Vector> OrigIpoptNLP::grad_f(const Vector& x)
266  {
267    SmartPtr<Vector> unscaled_grad_f;
268    SmartPtr<const Vector> retValue;
269    if (!grad_f_cache_.GetCachedResult1Dep(retValue, &x)) {
270      grad_f_evals_++;
271      unscaled_grad_f = x_space_->MakeNew();
272
273      SmartPtr<const Vector> unscaled_x = NLP_scaling()->unapply_vector_scaling_x(&x);
274      bool success = nlp_->Eval_grad_f(*unscaled_x, *unscaled_grad_f);
275      ASSERT_EXCEPTION(success && FiniteNumber(unscaled_grad_f->Nrm2()),
276                       Eval_Error, "Error evaluating the gradient of the objective function");
277      retValue = NLP_scaling()->apply_grad_obj_scaling(ConstPtr(unscaled_grad_f));
278      grad_f_cache_.AddCachedResult1Dep(retValue, &x);
279    }
280
281    return retValue;
282  }
283
284  /** Equality constraint residual */
285  SmartPtr<const Vector> OrigIpoptNLP::c(const Vector& x)
286  {
287    SmartPtr<const Vector> retValue;
288    SmartPtr<const Vector> dep;
289    if (c_space_->Dim()==0) {
290      // We do this caching of an empty vector so that the returned
291      // Vector has always the same tag (this might make a difference
292      // in cases where only the constraints are supposed to change...
293      dep = NULL;
294      if (!c_cache_.GetCachedResult1Dep(retValue, GetRawPtr(dep))) {
295        retValue = c_space_->MakeNew();
296        c_cache_.AddCachedResult1Dep(retValue, GetRawPtr(dep));
297      }
298    }
299    else {
300      dep = &x;
301    }
302    if (!c_cache_.GetCachedResult1Dep(retValue, GetRawPtr(dep))) {
303      SmartPtr<Vector> unscaled_c = c_space_->MakeNew();
304      c_evals_++;
305      SmartPtr<const Vector> unscaled_x = NLP_scaling()->unapply_vector_scaling_x(&x);
306      bool success = nlp_->Eval_c(*unscaled_x, *unscaled_c);
307      ASSERT_EXCEPTION(success && FiniteNumber(unscaled_c->Nrm2()),
308                       Eval_Error, "Error evaluating the equality constraints");
309      retValue = NLP_scaling()->apply_vector_scaling_c(ConstPtr(unscaled_c));
310      c_cache_.AddCachedResult1Dep(retValue, GetRawPtr(dep));
311    }
312
313    return retValue;
314  }
315
316  SmartPtr<const Vector> OrigIpoptNLP::d(const Vector& x)
317  {
318    DBG_START_METH("OrigIpoptNLP::d", dbg_verbosity);
319    SmartPtr<const Vector> retValue;
320    SmartPtr<const Vector> dep;
321    if (d_space_->Dim()==0) {
322      // We do this caching of an empty vector so that the returned
323      // Vector has always the same tag (this might make a difference
324      // in cases where only the constraints are supposed to change...
325      dep = NULL;
326      if (!d_cache_.GetCachedResult1Dep(retValue, GetRawPtr(dep))) {
327        retValue = d_space_->MakeNew();
328        d_cache_.AddCachedResult1Dep(retValue, GetRawPtr(dep));
329      }
330    }
331    else {
332      dep = &x;
333    }
334    if (!d_cache_.GetCachedResult1Dep(retValue, GetRawPtr(dep))) {
335      d_evals_++;
336      SmartPtr<Vector> unscaled_d = d_space_->MakeNew();
337
338      DBG_PRINT_VECTOR(2, "scaled_x", x);
339      SmartPtr<const Vector> unscaled_x = NLP_scaling()->unapply_vector_scaling_x(&x);
340      bool success = nlp_->Eval_d(*unscaled_x, *unscaled_d);
341      DBG_PRINT_VECTOR(2, "unscaled_d", *unscaled_d);
342      ASSERT_EXCEPTION(success && FiniteNumber(unscaled_d->Nrm2()),
343                       Eval_Error, "Error evaluating the inequality constraints");
344      retValue = NLP_scaling()->apply_vector_scaling_d(ConstPtr(unscaled_d));
345      d_cache_.AddCachedResult1Dep(retValue, GetRawPtr(dep));
346    }
347
348    return retValue;
349  }
350
351  SmartPtr<const Matrix> OrigIpoptNLP::jac_c(const Vector& x)
352  {
353    SmartPtr<const Matrix> retValue;
354    SmartPtr<const Vector> dep;
355    if (c_space_->Dim()==0) {
356      // We do this caching of an empty vector so that the returned
357      // Matrix has always the same tag
358      dep = NULL;
359      if (!jac_c_cache_.GetCachedResult1Dep(retValue, GetRawPtr(dep))) {
360        retValue = jac_c_space_->MakeNew();
361        jac_c_cache_.AddCachedResult1Dep(retValue, GetRawPtr(dep));
362      }
363    }
364    else {
365      dep = &x;
366    }
367    if (!jac_c_cache_.GetCachedResult1Dep(retValue, GetRawPtr(dep))) {
368      jac_c_evals_++;
369      SmartPtr<Matrix> unscaled_jac_c = jac_c_space_->MakeNew();
370
371      SmartPtr<const Vector> unscaled_x = NLP_scaling()->unapply_vector_scaling_x(&x);
372      bool success = nlp_->Eval_jac_c(*unscaled_x, *unscaled_jac_c);
373      ASSERT_EXCEPTION(success, Eval_Error, "Error evaluating the jacobian of the equality constraints");
374      retValue = NLP_scaling()->apply_jac_c_scaling(ConstPtr(unscaled_jac_c));
375      jac_c_cache_.AddCachedResult1Dep(retValue, GetRawPtr(dep));
376    }
377
378    return retValue;
379  }
380
381  SmartPtr<const Matrix> OrigIpoptNLP::jac_d(const Vector& x)
382  {
383    SmartPtr<const Matrix> retValue;
384    SmartPtr<const Vector> dep;
385    if (d_space_->Dim()==0) {
386      // We do this caching of an empty vector so that the returned
387      // Matrix has always the same tag
388      dep = NULL;
389      if (!jac_d_cache_.GetCachedResult1Dep(retValue, GetRawPtr(dep))) {
390        retValue = jac_d_space_->MakeNew();
391        jac_d_cache_.AddCachedResult1Dep(retValue, GetRawPtr(dep));
392      }
393    }
394    else {
395      dep = &x;
396    }
397    if (!jac_d_cache_.GetCachedResult1Dep(retValue, GetRawPtr(dep))) {
398      jac_d_evals_++;
399      SmartPtr<Matrix> unscaled_jac_d = jac_d_space_->MakeNew();
400
401      SmartPtr<const Vector> unscaled_x = NLP_scaling()->unapply_vector_scaling_x(&x);
402      bool success = nlp_->Eval_jac_d(*unscaled_x, *unscaled_jac_d);
403      ASSERT_EXCEPTION(success, Eval_Error, "Error evaluating the jacobian of the inequality constraints");
404      retValue = NLP_scaling()->apply_jac_d_scaling(ConstPtr(unscaled_jac_d));
405      jac_d_cache_.AddCachedResult1Dep(retValue, GetRawPtr(dep));
406    }
407
408    return retValue;
409  }
410
411  SmartPtr<const SymMatrix> OrigIpoptNLP::h(const Vector& x,
412      Number obj_factor,
413      const Vector& yc,
414      const Vector& yd)
415  {
416    std::vector<const TaggedObject*> deps(3);
417    deps[0] = &x;
418    deps[1] = &yc;
419    deps[2] = &yd;
420    std::vector<Number> scalar_deps(1);
421    scalar_deps[0] = obj_factor;
422
423    SmartPtr<SymMatrix> unscaled_h;
424    SmartPtr<const SymMatrix> retValue;
425    if (!h_cache_.GetCachedResult(retValue, deps, scalar_deps)) {
426      h_evals_++;
427      unscaled_h = h_space_->MakeNewSymMatrix();
428
429      SmartPtr<const Vector> unscaled_x = NLP_scaling()->unapply_vector_scaling_x(&x);
430      SmartPtr<const Vector> unscaled_yc = NLP_scaling()->apply_vector_scaling_c(&yc);
431      SmartPtr<const Vector> unscaled_yd = NLP_scaling()->apply_vector_scaling_d(&yd);
432      Number scaled_obj_factor = NLP_scaling()->apply_obj_scaling(obj_factor);
433      bool success = nlp_->Eval_h(*unscaled_x, scaled_obj_factor, *unscaled_yc, *unscaled_yd, *unscaled_h);
434      ASSERT_EXCEPTION(success, Eval_Error, "Error evaluating the hessian of the lagrangian");
435      retValue = NLP_scaling()->apply_hessian_scaling(ConstPtr(unscaled_h));
436      h_cache_.AddCachedResult(retValue, deps, scalar_deps);
437    }
438
439    return retValue;
440  }
441
442  void OrigIpoptNLP::GetSpaces(SmartPtr<const VectorSpace>& x_space,
443                               SmartPtr<const VectorSpace>& c_space,
444                               SmartPtr<const VectorSpace>& d_space,
445                               SmartPtr<const VectorSpace>& x_l_space,
446                               SmartPtr<const MatrixSpace>& px_l_space,
447                               SmartPtr<const VectorSpace>& x_u_space,
448                               SmartPtr<const MatrixSpace>& px_u_space,
449                               SmartPtr<const VectorSpace>& d_l_space,
450                               SmartPtr<const MatrixSpace>& pd_l_space,
451                               SmartPtr<const VectorSpace>& d_u_space,
452                               SmartPtr<const MatrixSpace>& pd_u_space,
453                               SmartPtr<const MatrixSpace>& Jac_c_space,
454                               SmartPtr<const MatrixSpace>& Jac_d_space,
455                               SmartPtr<const SymMatrixSpace>& Hess_lagrangian_space)
456  {
457    // Make sure that we already have all the pointers
458    DBG_ASSERT(IsValid(x_space_) &&
459               IsValid(c_space_) &&
460               IsValid(d_space_) &&
461               IsValid(x_l_space_) &&
462               IsValid(px_l_space_) &&
463               IsValid(x_u_space_) &&
464               IsValid(px_u_space_) &&
465               IsValid(d_l_space_) &&
466               IsValid(pd_l_space_) &&
467               IsValid(d_u_space_) &&
468               IsValid(pd_u_space_) &&
469               IsValid(scaled_jac_c_space_) &&
470               IsValid(scaled_jac_d_space_) &&
471               IsValid(scaled_h_space_));
472
473    DBG_ASSERT(IsValid(NLP_scaling()));
474
475    x_space = x_space_;
476    c_space = c_space_;
477    d_space = d_space_;
478    x_l_space = x_l_space_;
479    px_l_space = px_l_space_;
480    x_u_space = x_u_space_;
481    px_u_space = px_u_space_;
482    d_l_space = d_l_space_;
483    pd_l_space = pd_l_space_;
484    d_u_space = d_u_space_;
485    pd_u_space = pd_u_space_;
486    Jac_c_space = scaled_jac_c_space_;
487    Jac_d_space = scaled_jac_d_space_;
488    Hess_lagrangian_space = scaled_h_space_;
489  }
490
491  void OrigIpoptNLP::FinalizeSolution(SolverReturn status,
492                                      const Vector& x, const Vector& z_L, const Vector& z_U,
493                                      const Vector& c, const Vector& d,
494                                      const Vector& y_c, const Vector& y_d,
495                                      Number obj_value)
496  {
497    // need to submit the unscaled solution back to the nlp
498    SmartPtr<const Vector> unscaled_x =
499      NLP_scaling()->unapply_vector_scaling_x(&x);
500    SmartPtr<const Vector> unscaled_c =
501      NLP_scaling()->unapply_vector_scaling_c(&c);
502    SmartPtr<const Vector> unscaled_d =
503      NLP_scaling()->unapply_vector_scaling_d(&d);
504    const Number unscaled_obj = NLP_scaling()->unapply_obj_scaling(obj_value);
505
506    SmartPtr<const Vector> unscaled_z_L;
507    SmartPtr<const Vector> unscaled_z_U;
508    SmartPtr<const Vector> unscaled_y_c;
509    SmartPtr<const Vector> unscaled_y_d;
510
511    // The objective function scaling factor also appears in the constraints
512    Number obj_unscale_factor = NLP_scaling()->unapply_obj_scaling(1.);
513    if (obj_unscale_factor!=1.) {
514      SmartPtr<Vector> tmp = NLP_scaling()->apply_vector_scaling_x_LU_NonConst(*Px_L_, &z_L, *x_space_);
515      tmp->Scal(obj_unscale_factor);
516      unscaled_z_L = ConstPtr(tmp);
517
518      tmp = NLP_scaling()->apply_vector_scaling_x_LU_NonConst(*Px_U_, &z_U, *x_space_);
519      tmp->Scal(obj_unscale_factor);
520      unscaled_z_U = ConstPtr(tmp);
521
522      tmp = NLP_scaling()->apply_vector_scaling_c_NonConst(&y_c);
523      tmp->Scal(obj_unscale_factor);
524      unscaled_y_c = ConstPtr(tmp);
525
526      tmp = NLP_scaling()->apply_vector_scaling_d_NonConst(&y_d);
527      tmp->Scal(obj_unscale_factor);
528      unscaled_y_d = ConstPtr(tmp);
529    }
530    else {
531      unscaled_z_L = NLP_scaling()->apply_vector_scaling_x_LU(*Px_L_, &z_L, *x_space_);
532      unscaled_z_U = NLP_scaling()->apply_vector_scaling_x_LU(*Px_U_, &z_U, *x_space_);
533      unscaled_y_c = NLP_scaling()->apply_vector_scaling_c(&y_c);
534      unscaled_y_d = NLP_scaling()->apply_vector_scaling_d(&y_d);
535    }
536
537    nlp_->FinalizeSolution(status, *unscaled_x,
538                           *unscaled_z_L, *unscaled_z_U,
539                           *unscaled_c, *unscaled_d,
540                           *unscaled_y_c, *unscaled_y_d,
541                           unscaled_obj);
542  }
543
544  void OrigIpoptNLP::AdjustVariableBounds(const Vector& new_x_L, const Vector& new_x_U,
545                                          const Vector& new_d_L, const Vector& new_d_U)
546  {
547    x_L_ = new_x_L.MakeNewCopy();
548    x_U_ = new_x_U.MakeNewCopy();
549    d_L_ = new_d_L.MakeNewCopy();
550    d_U_ = new_d_U.MakeNewCopy();
551  }
552
553} // namespace Ipopt
Note: See TracBrowser for help on using the repository browser.