cbcintlinprog added

1 files changed, 550 insertions, 0 deletions

diff --git a/thirdparty/linux/include/coin/IpDenseVector.hpp b/thirdparty/linux/include/coin/IpDenseVector.hpp
new file mode 100644
index 0000000..380a06c
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpDenseVector.hpp
@@ -0,0 +1,550 @@
+// 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;
+
+  /** @name Exceptions */
+  //@{
+  DECLARE_STD_EXCEPTION(METADATA_ERROR);
+  //@}
+
+  /** Dense Vector Implementation.  This is the default Vector class
+   *  in Ipopt.  It stores vectors in contiguous Number arrays, unless
+   *  the vector has the same value in all entires.  In the latter
+   *  case, we call the vector "homogeneous", and we store only the
+   *  values that is repeated in all elements.  If you want to obtain
+   *  the values of vector, use the IsHomogeneous() method to find out
+   *  what status the vector is in, and then use either Values() const
+   *  or Scalar() const methods to get the values.  To set the values
+   *  of a homogeneous method, use the Set method.  To set the values
+   *  of a non-homogeneous vector, use the SetValues method, or use
+   *  the non-const Values method to get an array that you can
+   *  overwrite.  In the latter case, storage is ensured.
+   */
+  class DenseVector : public Vector
+  {
+  public:
+
+    /**@name Constructors / Destructors */
+    //@{
+    /** Default Constructor
+     */
+    DenseVector(const DenseVectorSpace* owner_space);
+
+    /** Destructor
+     */
+    virtual ~DenseVector();
+    //@}
+
+    /** @name Additional public methods not in Vector base class. */
+    //@{
+    /** Create a new DenseVector from same VectorSpace */
+    SmartPtr<DenseVector> MakeNewDenseVector() const;
+
+    /** Set elements in the vector to the Number array x. */
+    void SetValues(const Number *x);
+
+    /** Obtain pointer to the internal Number array with vector
+     *  elements with the indention to change the vector data (USE
+     *  WITH CARE!). This does not produce a copy, and lifetime is not
+     *  guaranteed!. 
+     */
+    inline Number* Values();
+
+    /** Obtain pointer to the internal Number array with vector
+     *  elements without the intention to change the vector data (USE
+     *  WITH CARE!). This does not produce a copy, and lifetime is not
+     *  guaranteed!  IMPORTANT: If this method is currently
+     *  homogeneous (i.e. IsHomogeneous returns true), then you cannot
+     *  call this method.  Instead, you need to use the Scalar()
+     *  method.
+     */
+    inline const Number* Values() const;
+
+    /** The same as the const version of Values, but we ensure that we
+     *  always return a valid array, even if IsHomogeneous returns
+     *  true. */
+    const Number* ExpandedValues() const;
+
+    /** This is the same as Values, but we add it here so that
+     *  ExpandedValues can also be used for the non-const case. */
+    inline Number* ExpandedValues()
+    {
+      return Values();
+    }
+
+    /** Indicates if the vector is homogeneous (i.e., all entries have
+     *  the value Scalar() */
+    bool IsHomogeneous() const
+    {
+      return homogeneous_;
+    }
+
+    /** Scalar value of all entries in a homogeneous vector */
+    Number Scalar() const
+    {
+      DBG_ASSERT(homogeneous_);
+      return scalar_;
+    }
+    //@}
+
+    /** @name Modifying subranges of the vector. */
+    //@{
+    /** Copy the data in x into the subrange of this vector starting
+     *  at position Pos in this vector.  Position count starts at 0.
+     */
+    void CopyToPos(Index Pos, const Vector& x);
+    /** Copy a subrange of x, starting at Pos, into the full data of
+     *  this vector.  Position count starts at 0.
+     */
+    void CopyFromPos(Index Pos, const Vector& x);
+    //@}
+
+  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);
+
+    /** Set entry to max of itself and the corresponding element in x */
+    virtual void ElementWiseMaxImpl(const Vector& x);
+
+    /** Set entry to min of itself and the corresponding element in x */
+    virtual void ElementWiseMinImpl(const Vector& x);
+
+    /** reciprocates the elements of the vector */
+    virtual void ElementWiseReciprocalImpl();
+
+    /** take abs of the elements of the vector */
+    virtual void ElementWiseAbsImpl();
+
+    /** take square-root of the elements of the vector */
+    virtual void ElementWiseSqrtImpl();
+
+    /** Changes each entry in the vector to its sgn value */
+    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);
+    //@}
+
+    /** @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
+    {
+      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:
+    /**@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 */
+    DenseVector();
+
+    /** Copy Constructor */
+    DenseVector(const DenseVector&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const DenseVector&);
+    //@}
+
+    /** Copy of the owner_space ptr as a DenseVectorSpace instead
+     *  of a VectorSpace
+     */
+    const DenseVectorSpace* owner_space_;
+
+    /** Dense Number array of vector values. */
+    Number* values_;
+
+    /** Dense Number array pointer that is used for ExpandedValues */
+    mutable Number* expanded_values_;
+
+    /** Method of getting the internal values array, making sure that
+     *  memory has been allocated */
+    inline
+    Number* values_allocated();
+
+    /** Flag for Initialization.  This flag is false, if the data has
+    not yet been initialized. */
+    bool initialized_;
+
+    /** Flag indicating whether the vector is currently homogeneous
+     *  (that is, all elements have the same value). This flag is used
+     *  to determine whether the elements of the vector are stored in
+     *  values_ or in scalar_ */
+    bool homogeneous_;
+
+    /** Homogeneous value of all elements if the vector is currently
+     *  homogenous */
+    Number scalar_;
+
+    /** Auxilliary method for setting explicitly all elements in
+     *  values_ to the current scalar value. */
+    void set_values_from_scalar();
+  };
+
+  /** typedefs for the map variables that define meta data for the
+   *  DenseVectorSpace
+   */
+  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;
+
+  /** This vectors space is the vector space for DenseVector.
+   */
+  class DenseVectorSpace : public VectorSpace
+  {
+  public:
+    /** @name Constructors/Destructors. */
+    //@{
+    /** Constructor, requires dimension of all vector for this
+     *  VectorSpace
+     */
+    DenseVectorSpace(Index dim)
+        :
+        VectorSpace(dim)
+    {}
+
+    /** Destructor */
+    ~DenseVectorSpace()
+    {}
+    //@}
+
+    /** Method for creating a new vector of this specific type. */
+    inline
+    DenseVector* MakeNewDenseVector() const
+    {
+      return new DenseVector(this);
+    }
+
+    /** Instantiation of the generate MakeNew method for the
+     *  VectorSpace base class.
+     */
+    virtual Vector* MakeNew() const
+    {
+      return MakeNewDenseVector();
+    }
+
+    /**@name Methods called by DenseVector for memory management.
+     * This could allow to have sophisticated memory management in the
+     * VectorSpace.
+     */
+    //@{
+    /** Allocate internal storage for the DenseVector */
+    inline
+    Number* AllocateInternalStorage() const;
+
+    /** Deallocate internal storage for the DenseVector */
+    inline
+    void FreeInternalStorage(Number* values) const;
+    //@}
+
+    /**@name Methods for dealing with meta data on the vector
+     */
+    //@{
+    /** Check if string meta exists for tag */
+    inline
+    bool HasStringMetaData(const std::string tag) const;
+
+    /** Check if Integer meta exists for tag */
+    inline
+    bool HasIntegerMetaData(const std::string tag) const;
+
+    /** Check if Numeric meta exists for tag */
+    inline
+    bool HasNumericMetaData(const std::string tag) const;
+
+    /** Get meta data of type std::string by tag */
+    inline
+    const std::vector<std::string>& GetStringMetaData(const std::string& tag) const;
+
+    /** Get meta data of type Index by tag */
+    inline
+    const std::vector<Index>& GetIntegerMetaData(const std::string& tag) const;
+
+    /** Get meta data of type Number by tag */
+    inline
+    const std::vector<Number>& GetNumericMetaData(const std::string& tag) const;
+
+    /** Set meta data of type std::string by tag */
+    inline
+    void SetStringMetaData(std::string tag, std::vector<std::string> meta_data);
+
+    /** Set meta data of type Index by tag */
+    inline
+    void SetIntegerMetaData(std::string tag, std::vector<Index> meta_data);
+
+    /** Set meta data of type Number by tag */
+    inline
+    void SetNumericMetaData(std::string tag, std::vector<Number> meta_data);
+
+    /** Get map of meta data of type Number */
+    inline
+    const StringMetaDataMapType& GetStringMetaData() const;
+
+    /** Get map of meta data of type Number */
+    inline
+    const IntegerMetaDataMapType& GetIntegerMetaData() const;
+
+    /** Get map of meta data of type Number */
+    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