IpIteratesVector.hpp
Go to the documentation of this file.
1 // Copyright (C) 2004, 2006 International Business Machines and others.
2 // All Rights Reserved.
3 // This code is published under the Eclipse Public License.
4 //
5 // $Id: IpIteratesVector.hpp 1861 2010-12-21 21:34:47Z andreasw $
6 //
7 // Authors: Carl Laird, Andreas Waechter IBM 2004-06-06
8 
9 #ifndef __IPITERATESVECTOR_HPP__
10 #define __IPITERATESVECTOR_HPP__
11 
12 #include "IpCompoundVector.hpp"
13 
14 namespace Ipopt
15 {
16  /* forward declarations */
17  class IteratesVectorSpace;
18 
28  {
29  public:
32  IteratesVector(const IteratesVectorSpace* owner_space, bool create_new);
33 
34  virtual ~IteratesVector();
36 
43  SmartPtr<IteratesVector> MakeNewIteratesVector(bool create_new = true) const;
44 
49  {
51  ret->Copy(*this);
52  return ret;
53  }
54 
63 
68  {
69  return GetIterateFromComp(0);
70  }
71 
76  {
78  }
79 
82 
86  {
87  SmartPtr<const Vector> curr_x = GetComp(0);
88  Set_x_NonConst(*curr_x->MakeNew());
89  x_NonConst()->Copy(*curr_x);
90  return x_NonConst();
91  }
92 
95  void Set_x(const Vector& vec)
96  {
97  SetComp(0, vec);
98  }
99 
103  {
104  SetCompNonConst(0, vec);
105  }
106 
109  {
110  return GetIterateFromComp(1);
111  }
112 
117  {
118  return GetNonConstIterateFromComp(1);
119  }
120 
123 
127  {
128  SmartPtr<const Vector> curr_s = GetComp(1);
129  Set_s_NonConst(*curr_s->MakeNew());
130  s_NonConst()->Copy(*curr_s);
131  return s_NonConst();
132  }
133 
136  void Set_s(const Vector& vec)
137  {
138  SetComp(1, vec);
139  }
140 
144  {
145  SetCompNonConst(1, vec);
146  }
147 
150  {
151  return GetIterateFromComp(2);
152  }
153 
158  {
159  return GetNonConstIterateFromComp(2);
160  }
161 
164 
168  {
169  SmartPtr<const Vector> curr_y_c = GetComp(2);
170  Set_y_c_NonConst(*curr_y_c->MakeNew());
171  y_c_NonConst()->Copy(*curr_y_c);
172  return y_c_NonConst();
173  }
174 
177  void Set_y_c(const Vector& vec)
178  {
179  SetComp(2, vec);
180  }
181 
185  {
186  SetCompNonConst(2, vec);
187  }
188 
191  {
192  return GetIterateFromComp(3);
193  }
194 
199  {
200  return GetNonConstIterateFromComp(3);
201  }
202 
205 
209  {
210  SmartPtr<const Vector> curr_y_d = GetComp(3);
211  Set_y_d_NonConst(*curr_y_d->MakeNew());
212  y_d_NonConst()->Copy(*curr_y_d);
213  return y_d_NonConst();
214  }
215 
218  void Set_y_d(const Vector& vec)
219  {
220  SetComp(3, vec);
221  }
222 
226  {
227  SetCompNonConst(3, vec);
228  }
229 
232  {
233  return GetIterateFromComp(4);
234  }
235 
240  {
241  return GetNonConstIterateFromComp(4);
242  }
243 
246 
250  {
251  SmartPtr<const Vector> curr_z_L = GetComp(4);
252  Set_z_L_NonConst(*curr_z_L->MakeNew());
253  z_L_NonConst()->Copy(*curr_z_L);
254  return z_L_NonConst();
255  }
256 
259  void Set_z_L(const Vector& vec)
260  {
261  SetComp(4, vec);
262  }
263 
267  {
268  SetCompNonConst(4, vec);
269  }
270 
273  {
274  return GetIterateFromComp(5);
275  }
276 
281  {
282  return GetNonConstIterateFromComp(5);
283  }
284 
287 
291  {
292  SmartPtr<const Vector> curr_z_U = GetComp(5);
293  Set_z_U_NonConst(*curr_z_U->MakeNew());
294  z_U_NonConst()->Copy(*curr_z_U);
295  return z_U_NonConst();
296  }
297 
300  void Set_z_U(const Vector& vec)
301  {
302  SetComp(5, vec);
303  }
304 
308  {
309  SetCompNonConst(5, vec);
310  }
311 
314  {
315  return GetIterateFromComp(6);
316  }
317 
322  {
323  return GetNonConstIterateFromComp(6);
324  }
325 
328 
332  {
333  SmartPtr<const Vector> curr_v_L = GetComp(6);
334  Set_v_L_NonConst(*curr_v_L->MakeNew());
335  v_L_NonConst()->Copy(*curr_v_L);
336  return v_L_NonConst();
337  }
338 
341  void Set_v_L(const Vector& vec)
342  {
343  SetComp(6, vec);
344  }
345 
349  {
350  SetCompNonConst(6, vec);
351  }
352 
355  {
356  return GetIterateFromComp(7);
357  }
358 
363  {
364  return GetNonConstIterateFromComp(7);
365  }
366 
369 
373  {
374  SmartPtr<const Vector> curr_v_U = GetComp(7);
375  Set_v_U_NonConst(*curr_v_U->MakeNew());
376  v_U_NonConst()->Copy(*curr_v_U);
377  return v_U_NonConst();
378  }
379 
382  void Set_v_U(const Vector& vec)
383  {
384  SetComp(7, vec);
385  }
386 
390  {
391  SetCompNonConst(7, vec);
392  }
393 
396  void Set_primal(const Vector& x, const Vector& s)
397  {
398  SetComp(0, x);
399  SetComp(1, s);
400  }
402  {
403  SetCompNonConst(0, x);
404  SetCompNonConst(1, s);
405  }
406 
409  void Set_eq_mult(const Vector& y_c, const Vector& y_d)
410  {
411  SetComp(2, y_c);
412  SetComp(3, y_d);
413  }
415  {
416  SetCompNonConst(2, y_c);
417  SetCompNonConst(3, y_d);
418  }
419 
422  void Set_bound_mult(const Vector& z_L, const Vector& z_U, const Vector& v_L, const Vector& v_U)
423  {
424  SetComp(4, z_L);
425  SetComp(5, z_U);
426  SetComp(6, v_L);
427  SetComp(7, v_U);
428  }
430  {
431  SetCompNonConst(4, z_L);
432  SetCompNonConst(5, z_U);
433  SetCompNonConst(6, v_L);
434  SetCompNonConst(7, v_U);
435  }
436 
443  {
444  TaggedObject::Tag tag = 0;
445 
446  if (IsValid(x())) {
447  tag += x()->GetTag();
448  }
449  if (IsValid(s())) {
450  tag += s()->GetTag();
451  }
452  if (IsValid(y_c())) {
453  tag += y_c()->GetTag();
454  }
455  if (IsValid(y_d())) {
456  tag += y_d()->GetTag();
457  }
458  if (IsValid(z_L())) {
459  tag += z_L()->GetTag();
460  }
461  if (IsValid(z_U())) {
462  tag += z_U()->GetTag();
463  }
464  if (IsValid(v_L())) {
465  tag += v_L()->GetTag();
466  }
467  if (IsValid(v_U())) {
468  tag += v_U()->GetTag();
469  }
470 
471  return tag;
472  }
474 
475  private:
484  IteratesVector();
485 
488 
490  void operator=(const IteratesVector&);
492 
494 
500  {
501  if (IsCompNull(i)) {
502  return NULL;
503  }
504  return GetComp(i);
505  }
506 
512  {
513  if (IsCompNull(i)) {
514  return NULL;
515  }
516  return GetCompNonConst(i);
517  }
518 
519  };
520 
525  {
526  public:
532  IteratesVectorSpace(const VectorSpace& x_space, const VectorSpace& s_space,
533  const VectorSpace& y_c_space, const VectorSpace& y_d_space,
534  const VectorSpace& z_L_space, const VectorSpace& z_U_space,
535  const VectorSpace& v_L_space, const VectorSpace& v_U_space
536  );
537 
538  virtual ~IteratesVectorSpace();
540 
547  virtual IteratesVector* MakeNewIteratesVector(bool create_new = true) const
548  {
549  return new IteratesVector(this, create_new);
550  }
551 
556  const Vector& y_c, const Vector& y_d,
557  const Vector& z_L, const Vector& z_U,
558  const Vector& v_L, const Vector& v_U)
559  {
561  newvec->Set_x(x);
562  newvec->Set_s(s);
563  newvec->Set_y_c(y_c);
564  newvec->Set_y_d(y_d);
565  newvec->Set_z_L(z_L);
566  newvec->Set_z_U(z_U);
567  newvec->Set_v_L(v_L);
568  newvec->Set_v_U(v_U);
569  return ConstPtr(newvec);
570  }
571 
572 
577  virtual CompoundVector* MakeNewCompoundVector(bool create_new = true) const
578  {
579  return MakeNewIteratesVector(create_new);
580  }
581 
587  virtual Vector* MakeNew() const
588  {
589  return MakeNewIteratesVector();
590  }
592 
597  virtual void SetCompSpace(Index icomp, const VectorSpace& vec_space)
598  {
599  DBG_ASSERT(false && "This is an IteratesVectorSpace - a special compound vector for Ipopt iterates. The contained spaces should not be modified.");
600  }
601 
602  private:
611 
614 
618 
628  };
629 
630 
631  inline
633  {
635  return x_NonConst();
636  }
637  inline
639  {
641  return s_NonConst();
642  }
643  inline
645  {
647  return y_c_NonConst();
648  }
649  inline
651  {
653  return y_d_NonConst();
654  }
655  inline
657  {
659  return z_L_NonConst();
660  }
661  inline
663  {
665  return z_U_NonConst();
666  }
667  inline
669  {
671  return v_L_NonConst();
672  }
673  inline
675  {
677  return v_U_NonConst();
678  }
679 } // namespace Ipopt
680 
681 #endif