IpIteratesVector.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-06-06
 
#ifndef __IPITERATESVECTOR_HPP__
#define __IPITERATESVECTOR_HPP__
 
#include "IpCompoundVector.hpp"
 
namespace Ipopt
{
/* forward declarations */
class IteratesVectorSpace;
 
class IPOPTLIB_EXPORT IteratesVector: public CompoundVector
{
public:
   IteratesVector(
      const IteratesVectorSpace* owner_space,
      bool                       create_new
   );
 
   virtual ~IteratesVector();
 
 
   SmartPtr<IteratesVector> MakeNewIteratesVector(
      bool create_new = true
   ) const;
 
   SmartPtr<IteratesVector> MakeNewIteratesVectorCopy() const
   {
      SmartPtr<IteratesVector> ret = MakeNewIteratesVector(true);
      ret->Copy(*this);
      return ret;
   }
 
   SmartPtr<IteratesVector> MakeNewContainer() const;
 
 
   SmartPtr<const Vector> x() const
   {
      return GetIterateFromComp(0);
   }
 
   SmartPtr<Vector> x_NonConst()
   {
      return GetNonConstIterateFromComp(0);
   }
 
   inline SmartPtr<Vector> create_new_x();
 
   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();
   }
 
   void Set_x(
      const Vector& vec
   )
   {
      SetComp(0, vec);
   }
 
   void Set_x_NonConst(
      Vector& vec
   )
   {
      SetCompNonConst(0, vec);
   }
 
   SmartPtr<const Vector> s() const
   {
      return GetIterateFromComp(1);
   }
 
   SmartPtr<Vector> s_NonConst()
   {
      return GetNonConstIterateFromComp(1);
   }
 
   inline SmartPtr<Vector> create_new_s();
 
   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();
   }
 
   void Set_s(
      const Vector& vec
   )
   {
      SetComp(1, vec);
   }
 
   void Set_s_NonConst(
      Vector& vec
   )
   {
      SetCompNonConst(1, vec);
   }
 
   SmartPtr<const Vector> y_c() const
   {
      return GetIterateFromComp(2);
   }
 
   SmartPtr<Vector> y_c_NonConst()
   {
      return GetNonConstIterateFromComp(2);
   }
 
   inline SmartPtr<Vector> create_new_y_c();
 
   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();
   }
 
   void Set_y_c(
      const Vector& vec
   )
   {
      SetComp(2, vec);
   }
 
   void Set_y_c_NonConst(
      Vector& vec
   )
   {
      SetCompNonConst(2, vec);
   }
 
   SmartPtr<const Vector> y_d() const
   {
      return GetIterateFromComp(3);
   }
 
   SmartPtr<Vector> y_d_NonConst()
   {
      return GetNonConstIterateFromComp(3);
   }
 
   inline SmartPtr<Vector> create_new_y_d();
 
   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();
   }
 
   void Set_y_d(
      const Vector& vec
   )
   {
      SetComp(3, vec);
   }
 
   void Set_y_d_NonConst(
      Vector& vec
   )
   {
      SetCompNonConst(3, vec);
   }
 
   SmartPtr<const Vector> z_L() const
   {
      return GetIterateFromComp(4);
   }
 
   SmartPtr<Vector> z_L_NonConst()
   {
      return GetNonConstIterateFromComp(4);
   }
 
   inline SmartPtr<Vector> create_new_z_L();
 
   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();
   }
 
   void Set_z_L(
      const Vector& vec
   )
   {
      SetComp(4, vec);
   }
 
   void Set_z_L_NonConst(
      Vector& vec
   )
   {
      SetCompNonConst(4, vec);
   }
 
   SmartPtr<const Vector> z_U() const
   {
      return GetIterateFromComp(5);
   }
 
   SmartPtr<Vector> z_U_NonConst()
   {
      return GetNonConstIterateFromComp(5);
   }
 
   inline SmartPtr<Vector> create_new_z_U();
 
   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();
   }
 
   void Set_z_U(
      const Vector& vec
   )
   {
      SetComp(5, vec);
   }
 
   void Set_z_U_NonConst(
      Vector& vec
   )
   {
      SetCompNonConst(5, vec);
   }
 
   SmartPtr<const Vector> v_L() const
   {
      return GetIterateFromComp(6);
   }
 
   SmartPtr<Vector> v_L_NonConst()
   {
      return GetNonConstIterateFromComp(6);
   }
 
   inline SmartPtr<Vector> create_new_v_L();
 
   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();
   }
 
   void Set_v_L(
      const Vector& vec
   )
   {
      SetComp(6, vec);
   }
 
   void Set_v_L_NonConst(
      Vector& vec
   )
   {
      SetCompNonConst(6, vec);
   }
 
   SmartPtr<const Vector> v_U() const
   {
      return GetIterateFromComp(7);
   }
 
   SmartPtr<Vector> v_U_NonConst()
   {
      return GetNonConstIterateFromComp(7);
   }
 
   inline SmartPtr<Vector> create_new_v_U();
 
   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();
   }
 
   void Set_v_U(
      const Vector& vec
   )
   {
      SetComp(7, vec);
   }
 
   void Set_v_U_NonConst(
      Vector& vec
   )
   {
      SetCompNonConst(7, vec);
   }
 
   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);
   }
 
   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);
   }
 
   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);
   }
 
   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:
 
   IteratesVector();
 
   IteratesVector(
      const IteratesVector&
   );
 
   void operator=(
      const IteratesVector&
   );
 
   const IteratesVectorSpace* owner_space_;
 
   SmartPtr<const Vector> GetIterateFromComp(
      Index i
   ) const
   {
      if( IsCompNull(i) )
      {
         return NULL;
      }
      return GetComp(i);
   }
 
   SmartPtr<Vector> GetNonConstIterateFromComp(
      Index i
   )
   {
      if( IsCompNull(i) )
      {
         return NULL;
      }
      return GetCompNonConst(i);
   }
 
};
 
class IPOPTLIB_EXPORT IteratesVectorSpace: public CompoundVectorSpace
{
public:
 
   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();
 
 
   virtual IteratesVector* MakeNewIteratesVector(
      bool create_new = true
   ) const
   {
      return new IteratesVector(this, create_new);
   }
 
   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);
   }
 
   virtual CompoundVector* MakeNewCompoundVector(
      bool create_new = true
   ) const
   {
      return MakeNewIteratesVector(create_new);
   }
 
   virtual Vector* MakeNew() const
   {
      return MakeNewIteratesVector();
   }
 
   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:
 
   IteratesVectorSpace();
 
   IteratesVectorSpace(
      const IteratesVectorSpace&
   );
 
   IteratesVectorSpace& operator=(
      const IteratesVectorSpace&
   );
 
   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