IpCompoundVector.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2006 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// 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 IPOPTLIB_EXPORT CompoundVector: public Vector
{
public:
 
   CompoundVector(
      const CompoundVectorSpace* owner_space,
      bool                       create_new
   );
 
   virtual ~CompoundVector() { }
 
   void SetComp(
      Index         icomp,
      const Vector& vec
   );
 
   void SetCompNonConst(
      Index   icomp,
      Vector& vec
   );
 
   inline Index NComps() const;
 
   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;
   }
 
   bool IsCompNull(
      Index i
   ) const
   {
      DBG_ASSERT(i >= 0 && i < NComps());
      if( IsValid(comps_[i]) || IsValid(const_comps_[i]) )
      {
         return false;
      }
      return true;
   }
 
   SmartPtr<const Vector> GetComp(
      Index i
   ) const
   {
      return ConstComp(i);
   }
 
   SmartPtr<Vector> GetCompNonConst(
      Index i
   )
   {
      ObjectChanged();
      return Comp(i);
   }
 
protected:
   virtual void CopyImpl(
      const Vector& x
   );
 
   virtual void ScalImpl(
      Number alpha
   );
 
   virtual void AxpyImpl(
      Number        alpha,
      const Vector& x
   );
 
   virtual Number DotImpl(
      const Vector& x
   ) const;
 
   virtual Number Nrm2Impl() const;
 
   virtual Number AsumImpl() const;
 
   virtual Number AmaxImpl() const;
 
   virtual void SetImpl(
      Number value
   );
 
   virtual void ElementWiseDivideImpl(
      const Vector& x
   );
 
   virtual void ElementWiseMultiplyImpl(
      const Vector& x
   );
 
   virtual void ElementWiseSelectImpl(
      const Vector& x
   );
 
   virtual void ElementWiseMaxImpl(
      const Vector& x
   );
 
   virtual void ElementWiseMinImpl(
      const Vector& x
   );
 
   virtual void ElementWiseReciprocalImpl();
 
   virtual void ElementWiseAbsImpl();
 
   virtual void ElementWiseSqrtImpl();
 
   virtual void ElementWiseSgnImpl();
 
   virtual void AddScalarImpl(
      Number scalar
   );
 
   virtual Number MaxImpl() const;
 
   virtual Number MinImpl() const;
 
   virtual Number SumImpl() const;
 
   virtual Number SumLogsImpl() const;
 
   void AddTwoVectorsImpl(
      Number        a,
      const Vector& v1,
      Number        b,
      const Vector& v2,
      Number        c
   );
 
   Number FracToBoundImpl(
      const Vector& delta,
      Number        tau
   ) const;
 
   void AddVectorQuotientImpl(
      Number        a,
      const Vector& z,
      const Vector& s,
      Number        c
   );
 
   virtual bool HasValidNumbersImpl() const;
 
   virtual void PrintImpl(
      const Journalist&  jnlst,
      EJournalLevel      level,
      EJournalCategory   category,
      const std::string& name,
      Index              indent,
      const std::string& prefix
   ) const;
 
private:
 
   CompoundVector();
 
   CompoundVector(
      const CompoundVector&
   );
 
   void operator=(
      const CompoundVector&
   );
 
   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
   );
};
 
class IPOPTLIB_EXPORT CompoundVectorSpace: public VectorSpace
{
public:
 
   CompoundVectorSpace(
      Index ncomp_spaces,
      Index total_dim
   );
 
   ~CompoundVectorSpace()
   { }
 
   virtual void SetCompSpace(
      Index              icomp,    
      const VectorSpace& vec_space 
   );
 
   SmartPtr<const VectorSpace> GetCompSpace(
      Index icomp
   ) const;
 
   Index NCompSpaces() const
   {
      return ncomp_spaces_;
   }
 
   virtual CompoundVector* MakeNewCompoundVector(
      bool create_new = true
   ) const
   {
      return new CompoundVector(this, create_new);
   }
 
   virtual Vector* MakeNew() const
   {
      return MakeNewCompoundVector();
   }
 
private:
 
   CompoundVectorSpace();
 
   CompoundVectorSpace(
      const CompoundVectorSpace&
   );
 
   CompoundVectorSpace& operator=(
      const CompoundVectorSpace&
   );
 
   const Index ncomp_spaces_;
 
   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