IpDenseVector.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2009 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 __IPDENSEVECTOR_HPP__
#define __IPDENSEVECTOR_HPP__
 
#include "IpUtils.hpp"
#include "IpVector.hpp"
#include <map>
 
namespace Ipopt
{
 
/* forward declarations */
class DenseVectorSpace;
 
DECLARE_STD_EXCEPTION(METADATA_ERROR);
 
class IPOPTLIB_EXPORT DenseVector: public Vector
{
public:
 
   DenseVector(
      const DenseVectorSpace* owner_space
   );
 
   virtual ~DenseVector();
 
 
   SmartPtr<DenseVector> MakeNewDenseVector() const;
 
   void SetValues(
      const Number* x
   );
 
   inline Number* Values();
 
   inline const Number* Values() const;
 
   const Number* ExpandedValues() const;
 
   inline Number* ExpandedValues()
   {
      return Values();
   }
 
   bool IsHomogeneous() const
   {
      return homogeneous_;
   }
 
   Number Scalar() const
   {
      DBG_ASSERT(homogeneous_);
      return scalar_;
   }
 
 
   void CopyToPos(
      Index         Pos,
      const Vector& x
   );
 
   void CopyFromPos(
      Index         Pos,
      const Vector& x
   );
 
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 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 void PrintImpl(
      const Journalist&  jnlst,
      EJournalLevel      level,
      EJournalCategory   category,
      const std::string& name,
      Index              indent,
      const std::string& prefix
   ) const
   {
      PrintImplOffset(jnlst, level, category, name, indent, prefix, 1);
   }
 
   /* Print the entire vector with padding, and start counting with an offset. */
   void PrintImplOffset(
      const Journalist&  jnlst,
      EJournalLevel      level,
      EJournalCategory   category,
      const std::string& name,
      Index              indent,
      const std::string& prefix,
      Index              offset
   ) const;
 
   friend class ParVector;
 
private:
 
   DenseVector();
 
   DenseVector(
      const DenseVector&
   );
 
   void operator=(
      const DenseVector&
   );
 
   const DenseVectorSpace* owner_space_;
 
   Number* values_;
 
   mutable Number* expanded_values_;
 
   inline Number* values_allocated();
 
   bool initialized_;
 
   bool homogeneous_;
 
   Number scalar_;
 
   void set_values_from_scalar();
};
 
typedef std::map<std::string, std::vector<std::string> > StringMetaDataMapType;
typedef std::map<std::string, std::vector<Index> > IntegerMetaDataMapType;
typedef std::map<std::string, std::vector<Number> > NumericMetaDataMapType;
 
class IPOPTLIB_EXPORT DenseVectorSpace: public VectorSpace
{
public:
 
   DenseVectorSpace(
      Index dim
   )
      : VectorSpace(dim)
   { }
 
   ~DenseVectorSpace()
   { }
 
   inline DenseVector* MakeNewDenseVector() const
   {
      return new DenseVector(this);
   }
 
   virtual Vector* MakeNew() const
   {
      return MakeNewDenseVector();
   }
 
 
   inline Number* AllocateInternalStorage() const;
 
   inline void FreeInternalStorage(
      Number* values
   ) const;
 
 
   inline
   bool HasStringMetaData(
      const std::string tag
   ) const;
 
   inline
   bool HasIntegerMetaData(
      const std::string tag
   ) const;
 
   inline
   bool HasNumericMetaData(
      const std::string tag
   ) const;
 
   inline const std::vector<std::string>& GetStringMetaData(
      const std::string& tag
   ) const;
 
   inline const std::vector<Index>& GetIntegerMetaData(
      const std::string& tag
   ) const;
 
   inline const std::vector<Number>& GetNumericMetaData(
      const std::string& tag
   ) const;
 
   inline void SetStringMetaData(
      std::string              tag,
      std::vector<std::string> meta_data
   );
 
   inline void SetIntegerMetaData(
      std::string        tag,
      std::vector<Index> meta_data
   );
 
   inline void SetNumericMetaData(
      std::string         tag,
      std::vector<Number> meta_data
   );
 
   inline const StringMetaDataMapType& GetStringMetaData() const;
 
   inline const IntegerMetaDataMapType& GetIntegerMetaData() const;
 
   inline const NumericMetaDataMapType& GetNumericMetaData() const;
 
private:
   // variables to store vector meta data
   StringMetaDataMapType string_meta_data_;
   IntegerMetaDataMapType integer_meta_data_;
   NumericMetaDataMapType numeric_meta_data_;
};
 
// inline functions
inline Number* DenseVector::Values()
{
   // Here we assume that every time someone requests this direct raw
   // pointer, the data is going to change and the Tag for this
   // vector has to be updated.
 
   if( initialized_ && homogeneous_ )
   {
      // If currently the vector is a homogeneous vector, set all elements
      // explicitly to this value
      set_values_from_scalar();
   }
   ObjectChanged();
   initialized_ = true;
   homogeneous_ = false;
   return values_allocated();
}
 
inline const Number* DenseVector::Values() const
{
   DBG_ASSERT(initialized_ && (Dim() == 0 || values_));
   return values_;
}
 
inline Number* DenseVector::values_allocated()
{
   if( values_ == NULL )
   {
      values_ = owner_space_->AllocateInternalStorage();
   }
   return values_;
}
 
inline Number* DenseVectorSpace::AllocateInternalStorage() const
{
   if( Dim() > 0 )
   {
      return new Number[Dim()];
   }
   else
   {
      return NULL;
   }
}
 
inline
void DenseVectorSpace::FreeInternalStorage(
   Number* values
) const
{
   delete[] values;
}
 
inline SmartPtr<DenseVector> DenseVector::MakeNewDenseVector() const
{
   return owner_space_->MakeNewDenseVector();
}
 
inline
bool DenseVectorSpace::HasStringMetaData(
   const std::string tag
) const
{
   StringMetaDataMapType::const_iterator iter;
   iter = string_meta_data_.find(tag);
 
   if( iter != string_meta_data_.end() )
   {
      return true;
   }
 
   return false;
}
 
inline
bool DenseVectorSpace::HasIntegerMetaData(
   const std::string tag
) const
{
   IntegerMetaDataMapType::const_iterator iter;
   iter = integer_meta_data_.find(tag);
 
   if( iter != integer_meta_data_.end() )
   {
      return true;
   }
 
   return false;
}
 
inline
bool DenseVectorSpace::HasNumericMetaData(
   const std::string tag
) const
{
   NumericMetaDataMapType::const_iterator iter;
   iter = numeric_meta_data_.find(tag);
 
   if( iter != numeric_meta_data_.end() )
   {
      return true;
   }
 
   return false;
}
 
inline const std::vector<std::string>& DenseVectorSpace::GetStringMetaData(
   const std::string& tag
) const
{
   DBG_ASSERT(HasStringMetaData(tag));
   StringMetaDataMapType::const_iterator iter;
   iter = string_meta_data_.find(tag);
   return iter->second;
}
 
inline const std::vector<Index>& DenseVectorSpace::GetIntegerMetaData(
   const std::string& tag
) const
{
   DBG_ASSERT(HasIntegerMetaData(tag));
   IntegerMetaDataMapType::const_iterator iter;
   iter = integer_meta_data_.find(tag);
   return iter->second;
}
 
inline const std::vector<Number>& DenseVectorSpace::GetNumericMetaData(
   const std::string& tag
) const
{
   DBG_ASSERT(HasNumericMetaData(tag));
   NumericMetaDataMapType::const_iterator iter;
   iter = numeric_meta_data_.find(tag);
   return iter->second;
}
 
inline void DenseVectorSpace::SetStringMetaData(
   std::string              tag,
   std::vector<std::string> meta_data
)
{
   string_meta_data_[tag] = meta_data;
}
 
inline void DenseVectorSpace::SetIntegerMetaData(
   std::string        tag,
   std::vector<Index> meta_data
)
{
   integer_meta_data_[tag] = meta_data;
}
 
inline void DenseVectorSpace::SetNumericMetaData(
   std::string         tag,
   std::vector<Number> meta_data
)
{
   numeric_meta_data_[tag] = meta_data;
}
 
inline const StringMetaDataMapType& DenseVectorSpace::GetStringMetaData() const
{
   return string_meta_data_;
}
 
inline const IntegerMetaDataMapType& DenseVectorSpace::GetIntegerMetaData() const
{
   return integer_meta_data_;
}
 
inline const NumericMetaDataMapType& DenseVectorSpace::GetNumericMetaData() const
{
   return numeric_meta_data_;
}
 
} // namespace Ipopt
#endif