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.
//
// $Id: IpDenseVector.hpp 2269 2013-05-05 11:32:40Z stefan $
//
// 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 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);

    /* 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
    {
      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 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