diff options
Diffstat (limited to 'thirdparty/linux/include/coin1/IpCompoundVector.hpp')
| -rw-r--r-- | thirdparty/linux/include/coin1/IpCompoundVector.hpp | 339 |
1 files changed, 339 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin1/IpCompoundVector.hpp b/thirdparty/linux/include/coin1/IpCompoundVector.hpp new file mode 100644 index 0000000..a4c52ab --- /dev/null +++ b/thirdparty/linux/include/coin1/IpCompoundVector.hpp @@ -0,0 +1,339 @@ +// Copyright (C) 2004, 2006 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Eclipse Public License. +// +// $Id: IpCompoundVector.hpp 2269 2013-05-05 11:32:40Z stefan $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPCOMPOUNDVECTOR_HPP__ +#define __IPCOMPOUNDVECTOR_HPP__ + +#include "IpUtils.hpp" +#include "IpVector.hpp" +#include <vector> + +namespace Ipopt +{ + + /* forward declarations */ + class CompoundVectorSpace; + + /** Class of Vectors consisting of other vectors. This vector is a + * vector that consists of zero, one or more Vector's which are + * stacked on each others: \f$ x_{\rm compound} = + * \left(\begin{array}{c}x_0\\\dots\\x_{{\rm + * ncomps} - 1}\end{array}\right)\f$. The individual components can be + * associated to different VectorSpaces. The individual components + * can also be const and non-const Vectors. + */ + class CompoundVector : public Vector + { + public: + /**@name Constructors/Destructors */ + //@{ + /** Constructor, given the corresponding CompoundVectorSpace. + * Before this constructor can be called, all components of the + * CompoundVectorSpace have to be set, so that the constructors + * for the individual components can be called. If the flag + * create_new is true, then the individual components of the new + * CompoundVector are initialized with the MakeNew methods of + * each VectorSpace (and are non-const). Otherwise, the + * individual components can later be set using the SetComp and + * SetCompNonConst method. + */ + CompoundVector(const CompoundVectorSpace* owner_space, bool create_new); + + /** Default destructor */ + virtual ~CompoundVector(); + //@} + + /** Method for setting the pointer for a component that is a const + * Vector + */ + void SetComp(Index icomp, const Vector& vec); + + /** Method for setting the pointer for a component that is a + * non-const Vector + */ + void SetCompNonConst(Index icomp, Vector& vec); + + /** Number of components of this compound vector */ + inline Index NComps() const; + + /** Check if a particular component is const or not */ + bool IsCompConst(Index i) const + { + DBG_ASSERT(i > 0 && i < NComps()); + DBG_ASSERT(IsValid(comps_[i]) || IsValid(const_comps_[i])); + if (IsValid(const_comps_[i])) { + return true; + } + return false; + } + + /** Check if a particular component is null or not */ + bool IsCompNull(Index i) const + { + DBG_ASSERT(i >= 0 && i < NComps()); + if (IsValid(comps_[i]) || IsValid(const_comps_[i])) { + return false; + } + return true; + } + + /** Return a particular component (const version) */ + SmartPtr<const Vector> GetComp(Index i) const + { + return ConstComp(i); + } + + /** Return a particular component (non-const version). Note that + * calling this method with mark the CompoundVector as changed. + * Therefore, only use this method if you are intending to change + * the Vector that you receive. + */ + SmartPtr<Vector> GetCompNonConst(Index i) + { + ObjectChanged(); + return Comp(i); + } + + protected: + /** @name Overloaded methods from Vector base class */ + //@{ + /** Copy the data of the vector x into this vector (DCOPY). */ + virtual void CopyImpl(const Vector& x); + + /** Scales the vector by scalar alpha (DSCAL) */ + virtual void ScalImpl(Number alpha); + + /** Add the multiple alpha of vector x to this vector (DAXPY) */ + virtual void AxpyImpl(Number alpha, const Vector &x); + + /** Computes inner product of vector x with this (DDOT) */ + virtual Number DotImpl(const Vector &x) const; + + /** Computes the 2-norm of this vector (DNRM2) */ + virtual Number Nrm2Impl() const; + + /** Computes the 1-norm of this vector (DASUM) */ + virtual Number AsumImpl() const; + + /** Computes the max-norm of this vector (based on IDAMAX) */ + virtual Number AmaxImpl() const; + + /** Set each element in the vector to the scalar alpha. */ + virtual void SetImpl(Number value); + + /** Element-wise division \f$y_i \gets y_i/x_i\f$.*/ + virtual void ElementWiseDivideImpl(const Vector& x); + + /** Element-wise multiplication \f$y_i \gets y_i*x_i\f$.*/ + virtual void ElementWiseMultiplyImpl(const Vector& x); + + /** Element-wise max against entries in x */ + virtual void ElementWiseMaxImpl(const Vector& x); + + /** Element-wise min against entries in x */ + virtual void ElementWiseMinImpl(const Vector& x); + + /** Element-wise reciprocal */ + virtual void ElementWiseReciprocalImpl(); + + /** Element-wise absolute values */ + virtual void ElementWiseAbsImpl(); + + /** Element-wise square-root */ + virtual void ElementWiseSqrtImpl(); + + /** Replaces entries with sgn of the entry */ + virtual void ElementWiseSgnImpl(); + + /** Add scalar to every component of the vector.*/ + virtual void AddScalarImpl(Number scalar); + + /** Max value in the vector */ + virtual Number MaxImpl() const; + + /** Min value in the vector */ + virtual Number MinImpl() const; + + /** Computes the sum of the lements of vector */ + virtual Number SumImpl() const; + + /** Computes the sum of the logs of the elements of vector */ + virtual Number SumLogsImpl() const; + + /** @name Implemented specialized functions */ + //@{ + /** Add two vectors (a * v1 + b * v2). Result is stored in this + vector. */ + void AddTwoVectorsImpl(Number a, const Vector& v1, + Number b, const Vector& v2, Number c); + /** Fraction to the boundary parameter. */ + Number FracToBoundImpl(const Vector& delta, Number tau) const; + /** Add the quotient of two vectors, y = a * z/s + c * y. */ + void AddVectorQuotientImpl(Number a, const Vector& z, const Vector& s, + Number c); + //@} + + /** Method for determining if all stored numbers are valid (i.e., + * no Inf or Nan). */ + virtual bool HasValidNumbersImpl() const; + + /** @name Output methods */ + //@{ + /* Print the entire vector with padding */ + virtual void PrintImpl(const Journalist& jnlst, + EJournalLevel level, + EJournalCategory category, + const std::string& name, + Index indent, + const std::string& prefix) const; + //@} + + 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 */ + CompoundVector(); + + /** Copy Constructor */ + CompoundVector(const CompoundVector&); + + /** Overloaded Equals Operator */ + void operator=(const CompoundVector&); + //@} + + /** Components of the compound vector. The components + * are stored by SmartPtrs in a std::vector + */ + std::vector< SmartPtr<Vector> > comps_; + std::vector< SmartPtr<const Vector> > const_comps_; + + const CompoundVectorSpace* owner_space_; + + bool vectors_valid_; + + bool VectorsValid(); + + inline const Vector* ConstComp(Index i) const; + + inline Vector* Comp(Index i); + }; + + /** This vectors space is the vector space for CompoundVector. + * Before a CompoundVector can be created, all components of this + * CompoundVectorSpace have to be set. When calling the constructor, + * the number of component has to be specified. The individual + * VectorSpaces can be set with the SetComp method. + */ + class CompoundVectorSpace : public VectorSpace + { + public: + /** @name Constructors/Destructors. */ + //@{ + /** Constructor, has to be given the number of components and the + * total dimension of all components combined. */ + CompoundVectorSpace(Index ncomp_spaces, Index total_dim); + + /** Destructor */ + ~CompoundVectorSpace() + {} + //@} + + /** Method for setting the individual component VectorSpaces */ + virtual void SetCompSpace(Index icomp /** Number of the component to be set */ , + const VectorSpace& vec_space /** VectorSpace for component icomp */ + ); + + /** Method for obtaining an individual component VectorSpace */ + SmartPtr<const VectorSpace> GetCompSpace(Index icomp) const; + + /** Accessor method to obtain the number of components */ + Index NCompSpaces() const + { + return ncomp_spaces_; + } + + /** Method for creating a new vector of this specific type. */ + virtual CompoundVector* MakeNewCompoundVector(bool create_new = true) const + { + return new CompoundVector(this, create_new); + } + + /** Overloaded MakeNew method for the VectorSpace base class. + */ + virtual Vector* MakeNew() const + { + return MakeNewCompoundVector(); + } + + 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 */ + CompoundVectorSpace(); + + /** Copy Constructor */ + CompoundVectorSpace(const CompoundVectorSpace&); + + /** Overloaded Equals Operator */ + CompoundVectorSpace& operator=(const CompoundVectorSpace&); + //@} + + /** Number of components */ + const Index ncomp_spaces_; + + /** std::vector of vector spaces for the components */ + std::vector< SmartPtr<const VectorSpace> > comp_spaces_; + }; + + /* inline methods */ + inline + Index CompoundVector::NComps() const + { + return owner_space_->NCompSpaces(); + } + + inline + const Vector* CompoundVector::ConstComp(Index i) const + { + DBG_ASSERT(i < NComps()); + DBG_ASSERT(IsValid(comps_[i]) || IsValid(const_comps_[i])); + if (IsValid(comps_[i])) { + return GetRawPtr(comps_[i]); + } + else if (IsValid(const_comps_[i])) { + return GetRawPtr(const_comps_[i]); + } + + DBG_ASSERT(false && "shouldn't be here"); + return NULL; + } + + inline + Vector* CompoundVector::Comp(Index i) + { + DBG_ASSERT(i < NComps()); + DBG_ASSERT(IsValid(comps_[i])); + return GetRawPtr(comps_[i]); + } + +} // namespace Ipopt + +#endif |