diff options
Diffstat (limited to 'thirdparty/linux/include/coin/IpIteratesVector.hpp')
| -rw-r--r-- | thirdparty/linux/include/coin/IpIteratesVector.hpp | 689 |
1 files changed, 689 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin/IpIteratesVector.hpp b/thirdparty/linux/include/coin/IpIteratesVector.hpp new file mode 100644 index 0000000..2ed7580 --- /dev/null +++ b/thirdparty/linux/include/coin/IpIteratesVector.hpp @@ -0,0 +1,689 @@ +// Copyright (C) 2004, 2006 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Eclipse Public License. +// +// $Id: IpIteratesVector.hpp 2472 2014-04-05 17:47:20Z stefan $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-06-06 + +#ifndef __IPITERATESVECTOR_HPP__ +#define __IPITERATESVECTOR_HPP__ + +#include "IpCompoundVector.hpp" + +namespace Ipopt +{ + /* forward declarations */ + class IteratesVectorSpace; + + /** Specialized CompoundVector class specifically for the algorithm + * iterates. This class inherits from CompoundVector and is a + * specialized class for handling the iterates of the Ipopt + * Algorithm, that is, x, s, y_c, y_d, z_L, z_U, v_L, and v_U. It + * inherits from CompoundVector so it can behave like a CV in most + * calculations, but it has fixed dimensions and cannot be + * customized + */ + class IteratesVector : public CompoundVector + { + public: + /** Constructors / Destructors */ + //@{ + IteratesVector(const IteratesVectorSpace* owner_space, bool create_new); + + virtual ~IteratesVector(); + //@} + + /** Make New methods */ + //@{ + /** Use this method to create a new iterates vector. The MakeNew + * method on the Vector class also works, but it does not give + * the create_new option. + */ + SmartPtr<IteratesVector> MakeNewIteratesVector(bool create_new = true) const; + + /** Use this method to create a new iterates vector with a copy of + * all the data. + */ + SmartPtr<IteratesVector> MakeNewIteratesVectorCopy() const + { + SmartPtr<IteratesVector> ret = MakeNewIteratesVector(true); + ret->Copy(*this); + return ret; + } + + /** Use this method to create a new iterates vector + * container. This creates a new NonConst container, but the + * elements inside the iterates vector may be const. Therefore, + * the container can be modified to point to new entries, but the + * existing entries may or may not be modifiable. + */ + SmartPtr<IteratesVector> MakeNewContainer() const; + //@} + + /** Iterates Set/Get Methods */ + //@{ + /** Get the x iterate (const) */ + SmartPtr<const Vector> x() const + { + return GetIterateFromComp(0); + } + + /** Get the x iterate (non-const) - this can only be called if the + * vector was created intenally, or the Set_x_NonConst method was + * used. */ + SmartPtr<Vector> x_NonConst() + { + return GetNonConstIterateFromComp(0); + } + + /** Create a new vector in the x entry */ + inline + SmartPtr<Vector> create_new_x(); + + /** Create a new vector in the x entry and copy the current values + * into it. */ + SmartPtr<Vector> create_new_x_copy() + { + SmartPtr<const Vector> curr_x = GetComp(0); + Set_x_NonConst(*curr_x->MakeNew()); + x_NonConst()->Copy(*curr_x); + return x_NonConst(); + } + + /** Set the x iterate (const). Sets the pointer, does NOT copy + * data. */ + void Set_x(const Vector& vec) + { + SetComp(0, vec); + } + + /** Set the x iterate (non-const). Sets the pointer, does NOT copy + * data. */ + void Set_x_NonConst(Vector& vec) + { + SetCompNonConst(0, vec); + } + + /** Get the s iterate (const) */ + SmartPtr<const Vector> s() const + { + return GetIterateFromComp(1); + } + + /** Get the s iterate (non-const) - this can only be called if the + * vector was created intenally, or the Set_s_NonConst method was + * used. */ + SmartPtr<Vector> s_NonConst() + { + return GetNonConstIterateFromComp(1); + } + + /** Create a new vector in the s entry */ + inline + SmartPtr<Vector> create_new_s(); + + /** Create a new vector in the s entry and copy the current values + * into it. */ + SmartPtr<Vector> create_new_s_copy() + { + SmartPtr<const Vector> curr_s = GetComp(1); + Set_s_NonConst(*curr_s->MakeNew()); + s_NonConst()->Copy(*curr_s); + return s_NonConst(); + } + + /** Set the s iterate (const). Sets the pointer, does NOT copy + * data. */ + void Set_s(const Vector& vec) + { + SetComp(1, vec); + } + + /** Set the s iterate (non-const). Sets the pointer, does NOT copy + * data. */ + void Set_s_NonConst(Vector& vec) + { + SetCompNonConst(1, vec); + } + + /** Get the y_c iterate (const) */ + SmartPtr<const Vector> y_c() const + { + return GetIterateFromComp(2); + } + + /** Get the y_c iterate (non-const) - this can only be called if + * the vector was created intenally, or the Set_y_c_NonConst + * method was used. */ + SmartPtr<Vector> y_c_NonConst() + { + return GetNonConstIterateFromComp(2); + } + + /** Create a new vector in the y_c entry */ + inline + SmartPtr<Vector> create_new_y_c(); + + /** Create a new vector in the y_c entry and copy the current + * values into it. */ + SmartPtr<Vector> create_new_y_c_copy() + { + SmartPtr<const Vector> curr_y_c = GetComp(2); + Set_y_c_NonConst(*curr_y_c->MakeNew()); + y_c_NonConst()->Copy(*curr_y_c); + return y_c_NonConst(); + } + + /** Set the y_c iterate (const). Sets the pointer, does NOT copy + * data. */ + void Set_y_c(const Vector& vec) + { + SetComp(2, vec); + } + + /** Set the y_c iterate (non-const). Sets the pointer, does NOT + * copy data. */ + void Set_y_c_NonConst(Vector& vec) + { + SetCompNonConst(2, vec); + } + + /** Get the y_d iterate (const) */ + SmartPtr<const Vector> y_d() const + { + return GetIterateFromComp(3); + } + + /** Get the y_d iterate (non-const) - this can only be called if + * the vector was created intenally, or the Set_y_d_NonConst + * method was used. */ + SmartPtr<Vector> y_d_NonConst() + { + return GetNonConstIterateFromComp(3); + } + + /** Create a new vector in the y_d entry */ + inline + SmartPtr<Vector> create_new_y_d(); + + /** Create a new vector in the y_d entry and copy the current + * values into it. */ + SmartPtr<Vector> create_new_y_d_copy() + { + SmartPtr<const Vector> curr_y_d = GetComp(3); + Set_y_d_NonConst(*curr_y_d->MakeNew()); + y_d_NonConst()->Copy(*curr_y_d); + return y_d_NonConst(); + } + + /** Set the y_d iterate (const). Sets the pointer, does NOT copy + * data. */ + void Set_y_d(const Vector& vec) + { + SetComp(3, vec); + } + + /** Set the y_d iterate (non-const). Sets the pointer, does NOT + * copy data. */ + void Set_y_d_NonConst(Vector& vec) + { + SetCompNonConst(3, vec); + } + + /** Get the z_L iterate (const) */ + SmartPtr<const Vector> z_L() const + { + return GetIterateFromComp(4); + } + + /** Get the z_L iterate (non-const) - this can only be called if + * the vector was created intenally, or the Set_z_L_NonConst + * method was used. */ + SmartPtr<Vector> z_L_NonConst() + { + return GetNonConstIterateFromComp(4); + } + + /** Create a new vector in the z_L entry */ + inline + SmartPtr<Vector> create_new_z_L(); + + /** Create a new vector in the z_L entry and copy the current + * values into it. */ + SmartPtr<Vector> create_new_z_L_copy() + { + SmartPtr<const Vector> curr_z_L = GetComp(4); + Set_z_L_NonConst(*curr_z_L->MakeNew()); + z_L_NonConst()->Copy(*curr_z_L); + return z_L_NonConst(); + } + + /** Set the z_L iterate (const). Sets the pointer, does NOT copy + * data. */ + void Set_z_L(const Vector& vec) + { + SetComp(4, vec); + } + + /** Set the z_L iterate (non-const). Sets the pointer, does NOT + * copy data. */ + void Set_z_L_NonConst(Vector& vec) + { + SetCompNonConst(4, vec); + } + + /** Get the z_U iterate (const) */ + SmartPtr<const Vector> z_U() const + { + return GetIterateFromComp(5); + } + + /** Get the z_U iterate (non-const) - this can only be called if + * the vector was created intenally, or the Set_z_U_NonConst + * method was used. */ + SmartPtr<Vector> z_U_NonConst() + { + return GetNonConstIterateFromComp(5); + } + + /** Create a new vector in the z_U entry */ + inline + SmartPtr<Vector> create_new_z_U(); + + /** Create a new vector in the z_U entry and copy the current + * values into it. */ + SmartPtr<Vector> create_new_z_U_copy() + { + SmartPtr<const Vector> curr_z_U = GetComp(5); + Set_z_U_NonConst(*curr_z_U->MakeNew()); + z_U_NonConst()->Copy(*curr_z_U); + return z_U_NonConst(); + } + + /** Set the z_U iterate (const). Sets the pointer, does NOT copy + * data. */ + void Set_z_U(const Vector& vec) + { + SetComp(5, vec); + } + + /** Set the z_U iterate (non-const). Sets the pointer, does NOT + * copy data. */ + void Set_z_U_NonConst(Vector& vec) + { + SetCompNonConst(5, vec); + } + + /** Get the v_L iterate (const) */ + SmartPtr<const Vector> v_L() const + { + return GetIterateFromComp(6); + } + + /** Get the v_L iterate (non-const) - this can only be called if + * the vector was created intenally, or the Set_v_L_NonConst + * method was used. */ + SmartPtr<Vector> v_L_NonConst() + { + return GetNonConstIterateFromComp(6); + } + + /** Create a new vector in the v_L entry */ + inline + SmartPtr<Vector> create_new_v_L(); + + /** Create a new vector in the v_L entry and copy the current + * values into it. */ + SmartPtr<Vector> create_new_v_L_copy() + { + SmartPtr<const Vector> curr_v_L = GetComp(6); + Set_v_L_NonConst(*curr_v_L->MakeNew()); + v_L_NonConst()->Copy(*curr_v_L); + return v_L_NonConst(); + } + + /** Set the v_L iterate (const). Sets the pointer, does NOT copy + * data. */ + void Set_v_L(const Vector& vec) + { + SetComp(6, vec); + } + + /** Set the v_L iterate (non-const). Sets the pointer, does NOT + * copy data. */ + void Set_v_L_NonConst(Vector& vec) + { + SetCompNonConst(6, vec); + } + + /** Get the v_U iterate (const) */ + SmartPtr<const Vector> v_U() const + { + return GetIterateFromComp(7); + } + + /** Get the v_U iterate (non-const) - this can only be called if + * the vector was created intenally, or the Set_v_U_NonConst + * method was used. */ + SmartPtr<Vector> v_U_NonConst() + { + return GetNonConstIterateFromComp(7); + } + + /** Create a new vector in the v_U entry */ + inline + SmartPtr<Vector> create_new_v_U(); + + /** Create a new vector in the v_U entry and copy the current + * values into it. */ + SmartPtr<Vector> create_new_v_U_copy() + { + SmartPtr<const Vector> curr_v_U = GetComp(7); + Set_v_U_NonConst(*curr_v_U->MakeNew()); + v_U_NonConst()->Copy(*curr_v_U); + return v_U_NonConst(); + } + + /** Set the v_U iterate (const). Sets the pointer, does NOT copy + * data. */ + void Set_v_U(const Vector& vec) + { + SetComp(7, vec); + } + + /** Set the v_U iterate (non-const). Sets the pointer, does NOT + * copy data. */ + void Set_v_U_NonConst(Vector& vec) + { + SetCompNonConst(7, vec); + } + + /** Set the primal variables all in one shot. Sets the pointers, + * does NOT copy data */ + void Set_primal(const Vector& x, const Vector& s) + { + SetComp(0, x); + SetComp(1, s); + } + void Set_primal_NonConst(Vector& x, Vector& s) + { + SetCompNonConst(0, x); + SetCompNonConst(1, s); + } + + /** Set the eq multipliers all in one shot. Sets the pointers, + * does not copy data. */ + void Set_eq_mult(const Vector& y_c, const Vector& y_d) + { + SetComp(2, y_c); + SetComp(3, y_d); + } + void Set_eq_mult_NonConst(Vector& y_c, Vector& y_d) + { + SetCompNonConst(2, y_c); + SetCompNonConst(3, y_d); + } + + /** Set the bound multipliers all in one shot. Sets the pointers, + * does not copy data. */ + void Set_bound_mult(const Vector& z_L, const Vector& z_U, const Vector& v_L, const Vector& v_U) + { + SetComp(4, z_L); + SetComp(5, z_U); + SetComp(6, v_L); + SetComp(7, v_U); + } + void Set_bound_mult_NonConst(Vector& z_L, Vector& z_U, Vector& v_L, Vector& v_U) + { + SetCompNonConst(4, z_L); + SetCompNonConst(5, z_U); + SetCompNonConst(6, v_L); + SetCompNonConst(7, v_U); + } + + /** Get a sum of the tags of the contained items. There is no + * guarantee that this is unique, but there is a high chance it + * is unique and it can be used for debug checks relatively + * reliably. + */ + TaggedObject::Tag GetTagSum() const + { + TaggedObject::Tag tag = 0; + + if (IsValid(x())) { + tag += x()->GetTag(); + } + if (IsValid(s())) { + tag += s()->GetTag(); + } + if (IsValid(y_c())) { + tag += y_c()->GetTag(); + } + if (IsValid(y_d())) { + tag += y_d()->GetTag(); + } + if (IsValid(z_L())) { + tag += z_L()->GetTag(); + } + if (IsValid(z_U())) { + tag += z_U()->GetTag(); + } + if (IsValid(v_L())) { + tag += v_L()->GetTag(); + } + if (IsValid(v_U())) { + tag += v_U()->GetTag(); + } + + return tag; + } + //@} + + private: + /**@name Default Compiler Generated Methods (Hidden to avoid + * implicit creation/calling). These methods are not implemented + * and we do not want the compiler to implement them for us, so we + * declare them private and do not define them. This ensures that + * they will not be implicitly created/called. + */ + //@{ + /** Default Constructor */ + IteratesVector(); + + /** Copy Constructor */ + IteratesVector(const IteratesVector&); + + /** Overloaded Equals Operator */ + void operator=(const IteratesVector&); + //@} + + const IteratesVectorSpace* owner_space_; + + /** private method to return the const element from the compound + * vector. This method will return NULL if none is currently + * set. + */ + SmartPtr<const Vector> GetIterateFromComp(Index i) const + { + if (IsCompNull(i)) { + return NULL; + } + return GetComp(i); + } + + /** private method to return the non-const element from the + * compound vector. This method will return NULL if none is + * currently set. + */ + SmartPtr<Vector> GetNonConstIterateFromComp(Index i) + { + if (IsCompNull(i)) { + return NULL; + } + return GetCompNonConst(i); + } + + }; + + /** Vector Space for the IteratesVector class. This is a + * specialized vector space for the IteratesVector class. + */ + class IteratesVectorSpace : public CompoundVectorSpace + { + public: + /** @name Constructors/Destructors. */ + //@{ + /** Constructor that takes the spaces for each of the iterates. + * Warning! None of these can be NULL ! + */ + IteratesVectorSpace(const VectorSpace& x_space, const VectorSpace& s_space, + const VectorSpace& y_c_space, const VectorSpace& y_d_space, + const VectorSpace& z_L_space, const VectorSpace& z_U_space, + const VectorSpace& v_L_space, const VectorSpace& v_U_space + ); + + virtual ~IteratesVectorSpace(); + //@} + + /** Method for creating vectors . */ + //@{ + /** Use this to create a new IteratesVector. You can pass-in + * create_new = false if you only want a container and do not + * want vectors allocated. + */ + virtual IteratesVector* MakeNewIteratesVector(bool create_new = true) const + { + return new IteratesVector(this, create_new); + } + + /** Use this method to create a new const IteratesVector. You must pass in + * valid pointers for all of the entries. + */ + const SmartPtr<const IteratesVector> MakeNewIteratesVector(const Vector& x, const Vector& s, + const Vector& y_c, const Vector& y_d, + const Vector& z_L, const Vector& z_U, + const Vector& v_L, const Vector& v_U) + { + SmartPtr<IteratesVector> newvec = MakeNewIteratesVector(false); + newvec->Set_x(x); + newvec->Set_s(s); + newvec->Set_y_c(y_c); + newvec->Set_y_d(y_d); + newvec->Set_z_L(z_L); + newvec->Set_z_U(z_U); + newvec->Set_v_L(v_L); + newvec->Set_v_U(v_U); + return ConstPtr(newvec); + } + + + /** This method overloads + * ComooundVectorSpace::MakeNewCompoundVector to make sure that + * we get a vector of the correct type + */ + virtual CompoundVector* MakeNewCompoundVector(bool create_new = true) const + { + return MakeNewIteratesVector(create_new); + } + + /** This method creates a new vector (and allocates space in all + * the contained vectors. This is really only used for code that + * does not know what type of vector it is dealing with - for + * example, this method is called from Vector::MakeNew() + */ + virtual Vector* MakeNew() const + { + return MakeNewIteratesVector(); + } + //@} + + /** This method hides the CompoundVectorSpace::SetCompSpace method + * since the components of the Iterates are fixed at + * construction. + */ + virtual void SetCompSpace(Index icomp, const VectorSpace& vec_space) + { + DBG_ASSERT(false && "This is an IteratesVectorSpace - a special compound vector for Ipopt iterates. The contained spaces should not be modified."); + } + + private: + /**@name Default Compiler Generated Methods (Hidden to avoid + * implicit creation/calling). These methods are not implemented + * and we do not want the compiler to implement them for us, so we + * declare them private and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Default constructor */ + IteratesVectorSpace(); + + /** Copy Constructor */ + IteratesVectorSpace(const IteratesVectorSpace&); + + /** Overloaded Equals Operator */ + IteratesVectorSpace& operator=(const IteratesVectorSpace&); + //@} + + /** Contained Spaces */ + SmartPtr<const VectorSpace> x_space_; + SmartPtr<const VectorSpace> s_space_; + SmartPtr<const VectorSpace> y_c_space_; + SmartPtr<const VectorSpace> y_d_space_; + SmartPtr<const VectorSpace> z_L_space_; + SmartPtr<const VectorSpace> z_U_space_; + SmartPtr<const VectorSpace> v_L_space_; + SmartPtr<const VectorSpace> v_U_space_; + }; + + + inline + SmartPtr<Vector> IteratesVector::create_new_x() + { + Set_x_NonConst(*owner_space_->GetCompSpace(0)->MakeNew()); + return x_NonConst(); + } + inline + SmartPtr<Vector> IteratesVector::create_new_s() + { + Set_s_NonConst(*owner_space_->GetCompSpace(1)->MakeNew()); + return s_NonConst(); + } + inline + SmartPtr<Vector> IteratesVector::create_new_y_c() + { + Set_y_c_NonConst(*owner_space_->GetCompSpace(2)->MakeNew()); + return y_c_NonConst(); + } + inline + SmartPtr<Vector> IteratesVector::create_new_y_d() + { + Set_y_d_NonConst(*owner_space_->GetCompSpace(3)->MakeNew()); + return y_d_NonConst(); + } + inline + SmartPtr<Vector> IteratesVector::create_new_z_L() + { + Set_z_L_NonConst(*owner_space_->GetCompSpace(4)->MakeNew()); + return z_L_NonConst(); + } + inline + SmartPtr<Vector> IteratesVector::create_new_z_U() + { + Set_z_U_NonConst(*owner_space_->GetCompSpace(5)->MakeNew()); + return z_U_NonConst(); + } + inline + SmartPtr<Vector> IteratesVector::create_new_v_L() + { + Set_v_L_NonConst(*owner_space_->GetCompSpace(6)->MakeNew()); + return v_L_NonConst(); + } + inline + SmartPtr<Vector> IteratesVector::create_new_v_U() + { + Set_v_U_NonConst(*owner_space_->GetCompSpace(7)->MakeNew()); + return v_U_NonConst(); + } +} // namespace Ipopt + +#endif |