Added linux shared libraries and header files for int and ecos functions

1 files changed, 340 insertions, 0 deletions

diff --git a/thirdparty/linux/include/coin1/IpCompoundMatrix.hpp b/thirdparty/linux/include/coin1/IpCompoundMatrix.hpp
new file mode 100644
index 0000000..03e2e2a
--- /dev/null
+++ b/thirdparty/linux/include/coin1/IpCompoundMatrix.hpp
@@ -0,0 +1,340 @@
+// Copyright (C) 2004, 2009 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpCompoundMatrix.hpp 2269 2013-05-05 11:32:40Z stefan $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPCOMPOUNDMATRIX_HPP__
+#define __IPCOMPOUNDMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpMatrix.hpp"
+
+namespace Ipopt
+{
+
+  /* forward declarations */
+  class CompoundMatrixSpace;
+
+  /** Class for Matrices consisting of other matrices.  This matrix is
+   *  a matrix that consists of zero, one or more Matrices's which are
+   *  arranged like this: \f$ M_{\rm compound} =
+   *  \left(\begin{array}{cccc}M_{00} & M_{01} & \ldots & M_{0,{\rm
+   *  ncomp\_cols}-1} \\ \dots &&&\dots \\ M_{{\rm ncomp\_rows}-1,0} &
+   *  M_{{\rm ncomp\_rows}-1,1} & \dots & M_{{\rm ncomp\_rows}-1,{\rm
+   *  ncomp\_cols}-1}\end{array}\right)\f$.  The individual components
+   *  can be associated to different MatrixSpaces.  The individual
+   *  components can also be const and non-const Matrices.  If a
+   *  component is not set (i.e., it's pointer is NULL), then this
+   *  components is treated like a zero-matrix of appropriate
+   *  dimensions.
+   */
+  class CompoundMatrix : public Matrix
+  {
+  public:
+
+    /**@name Constructors / Destructors */
+    //@{
+
+    /** Constructor, taking the owner_space.  The owner_space has to
+     *  be defined, so that at each block row and column contain at
+     *  least one non-NULL component.  The individual components can
+     *  be set afterwards with the SeteComp and SetCompNonConst
+     *  methods.
+     */
+    CompoundMatrix(const CompoundMatrixSpace* owner_space);
+
+    /** Destructor */
+    virtual ~CompoundMatrix();
+    //@}
+
+    /** Method for setting an individual component at position (irow,
+     *  icol) in the compound matrix.  The counting of indices starts
+     *  at 0. */
+    void SetComp(Index irow, Index jcol, const Matrix& matrix);
+
+    /** Method to set a non-const Matrix entry */
+    void SetCompNonConst(Index irow, Index jcol, Matrix& matrix);
+
+    /** Method to create a new matrix from the space for this block */
+    void CreateBlockFromSpace(Index irow, Index jcol);
+
+    /** Method for retrieving one block from the compound matrix as a
+     *  const Matrix.
+     */
+    SmartPtr<const Matrix> GetComp(Index irow, Index jcol) const
+    {
+      return ConstComp(irow, jcol);
+    }
+
+    /** Method for retrieving one block from the compound matrix as a
+     *  non-const Matrix.  Note that calling this method with mark the
+     *  CompoundMatrix as changed.  Therefore, only use this method if
+     *  you are intending to change the Matrix that you receive. */
+    SmartPtr<Matrix> GetCompNonConst(Index irow, Index jcol)
+    {
+      ObjectChanged();
+      return Comp(irow, jcol);
+    }
+
+    /** Number of block rows of this compound matrix. */
+    inline Index NComps_Rows() const;
+    /** Number of block colmuns of this compound matrix. */
+    inline Index NComps_Cols() const;
+
+  protected:
+    /**@name Methods overloaded from Matrix */
+    //@{
+    virtual void MultVectorImpl(Number alpha, const Vector& x,
+                                Number beta, Vector& y) const;
+
+    virtual void TransMultVectorImpl(Number alpha, const Vector& x,
+                                     Number beta, Vector& y) const;
+
+    /** X = beta*X + alpha*(Matrix S^{-1} Z).  Specialized implementation.
+     */
+    virtual void AddMSinvZImpl(Number alpha, const Vector& S, const Vector& Z,
+                               Vector& X) const;
+
+    /** X = S^{-1} (r + alpha*Z*M^Td).  Specialized implementation.
+     */
+    virtual void SinvBlrmZMTdBrImpl(Number alpha, const Vector& S,
+                                    const Vector& R, const Vector& Z,
+                                    const Vector& D, Vector& X) const;
+
+    /** Method for determining if all stored numbers are valid (i.e.,
+     *  no Inf or Nan). */
+    virtual bool HasValidNumbersImpl() const;
+
+    virtual void ComputeRowAMaxImpl(Vector& rows_norms, bool init) const;
+
+    virtual void ComputeColAMaxImpl(Vector& cols_norms, bool init) const;
+
+    virtual void PrintImpl(const Journalist& jnlst,
+                           EJournalLevel level,
+                           EJournalCategory category,
+                           const std::string& name,
+                           Index indent,
+                           const std::string& prefix) const;
+    //@}
+
+  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 */
+    CompoundMatrix();
+
+    /** Copy Constructor */
+    CompoundMatrix(const CompoundMatrix&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const CompoundMatrix&);
+    //@}
+
+    /** Matrix of matrix's containing the components */
+    std::vector<std::vector<SmartPtr<Matrix> > > comps_;
+
+    /** Matrix of const matrix's containing the components */
+    std::vector<std::vector<SmartPtr<const Matrix> > > const_comps_;
+
+    /** Copy of the owner_space ptr as a CompoundMatrixSpace instead
+     *  of MatrixSpace */
+    const CompoundMatrixSpace* owner_space_;
+
+    /** boolean indicating if the compound matrix is in a "valid" state */
+    mutable bool matrices_valid_;
+
+    /** Method to check whether or not the matrices are valid */
+    bool MatricesValid() const;
+
+    inline const Matrix* ConstComp(Index irow, Index jcol) const;
+
+    inline Matrix* Comp(Index irow, Index jcol);
+  };
+
+  /** This is the matrix space for CompoundMatrix.  Before a CompoundMatrix
+   *  can be created, at least one MatrixSpace has to be set per block
+   *  row and column.  Individual component MatrixSpace's can be set
+   *  with the SetComp method.
+   */
+  class CompoundMatrixSpace : public MatrixSpace
+  {
+  public:
+    /** @name Constructors / Destructors */
+    //@{
+    /** Constructor, given the number of row and columns blocks, as
+     *  well as the totel number of rows and columns.
+     */
+    CompoundMatrixSpace(Index ncomps_rows,
+                        Index ncomps_cols,
+                        Index total_nRows,
+                        Index total_nCols);
+
+    /** Destructor */
+    ~CompoundMatrixSpace()
+    {}
+    //@}
+
+    /** @name Methods for setting information about the components. */
+    //@{
+    /** Set the number nrows of rows in row-block number irow. */
+    void SetBlockRows(Index irow, Index nrows);
+
+    /** Set the number ncols of columns in column-block number jcol. */
+    void SetBlockCols(Index jcol, Index ncols);
+
+    /** Get the number nrows of rows in row-block number irow. */
+    Index GetBlockRows(Index irow) const;
+
+    /** Set the number ncols of columns in column-block number jcol. */
+    Index GetBlockCols(Index jcol) const;
+
+    /** Set the component MatrixSpace.  If auto_allocate is true, then
+     *  a new CompoundMatrix created later with MakeNew will have this
+     *  component automatically created with the Matrix's MakeNew.
+     *  Otherwise, the corresponding component will be NULL and has to
+     *  be set with the SetComp methods of the CompoundMatrix.
+     */
+    void SetCompSpace(Index irow, Index jcol,
+                      const MatrixSpace& mat_space,
+                      bool auto_allocate = false);
+    //@}
+
+    /** Obtain the component MatrixSpace in block row irow and block
+     *  column jcol.
+     */
+    SmartPtr<const MatrixSpace> GetCompSpace(Index irow, Index jcol) const
+    {
+      DBG_ASSERT(irow<NComps_Rows());
+      DBG_ASSERT(jcol<NComps_Cols());
+      return comp_spaces_[irow][jcol];
+    }
+
+    /** @name Accessor methods */
+    //@{
+    /** Number of block rows */
+    Index NComps_Rows() const
+    {
+      return ncomps_rows_;
+    }
+    /** Number of block columns */
+    Index NComps_Cols() const
+    {
+      return ncomps_cols_;
+    }
+
+    /** True if the blocks lie on the diagonal - can make some operations faster */
+    bool Diagonal() const
+    {
+      return diagonal_;
+    }
+    //@}
+
+    /** Method for creating a new matrix of this specific type. */
+    CompoundMatrix* MakeNewCompoundMatrix() const;
+
+    /** Overloaded MakeNew method for the MatrixSpace base class.
+     */
+    virtual Matrix* MakeNew() const
+    {
+      return MakeNewCompoundMatrix();
+    }
+
+  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 */
+    CompoundMatrixSpace();
+
+    /** Copy Constructor */
+    CompoundMatrixSpace(const CompoundMatrixSpace&);
+
+    /** Overloaded Equals Operator */
+    CompoundMatrixSpace& operator=(const CompoundMatrixSpace&);
+    //@}
+
+    /** Number of block rows */
+    Index ncomps_rows_;
+
+    /** Number of block columns */
+    Index ncomps_cols_;
+
+    /** Store whether or not the dimensions are valid */
+    mutable bool dimensions_set_;
+
+    /** 2-dim std::vector of matrix spaces for the components */
+    std::vector<std::vector<SmartPtr<const MatrixSpace> > > comp_spaces_;
+
+    /** 2-dim std::vector of booleans deciding whether to
+     *  allocate a new matrix for the blocks automagically */
+    std::vector<std::vector< bool > > allocate_block_;
+
+    /** Vector of the number of rows in each comp column */
+    std::vector<Index> block_rows_;
+
+    /** Vector of the number of cols in each comp row */
+    std::vector<Index> block_cols_;
+
+    /** true if the CompoundMatrixSpace only has Matrix spaces along the diagonal.
+     *  this means that the CompoundMatrix will only have matrices along the 
+     *  diagonal and it could make some operations more efficient
+     */
+    bool diagonal_;
+
+    /** Auxilliary function for debugging to set if all block
+     *  dimensions have been set. */
+    bool DimensionsSet() const;
+  };
+
+  /* inline methods */
+  inline
+  Index CompoundMatrix::NComps_Rows() const
+  {
+    return owner_space_->NComps_Rows();
+  }
+
+  inline
+  Index CompoundMatrix::NComps_Cols() const
+  {
+    return owner_space_->NComps_Cols();
+  }
+
+  inline
+  const Matrix* CompoundMatrix::ConstComp(Index irow, Index jcol) const
+  {
+    DBG_ASSERT(irow < NComps_Rows());
+    DBG_ASSERT(jcol < NComps_Cols());
+    if (IsValid(comps_[irow][jcol])) {
+      return GetRawPtr(comps_[irow][jcol]);
+    }
+    else if (IsValid(const_comps_[irow][jcol])) {
+      return GetRawPtr(const_comps_[irow][jcol]);
+    }
+
+    return NULL;
+  }
+
+  inline
+  Matrix* CompoundMatrix::Comp(Index irow, Index jcol)
+  {
+    DBG_ASSERT(irow < NComps_Rows());
+    DBG_ASSERT(jcol < NComps_Cols());
+    return GetRawPtr(comps_[irow][jcol]);
+  }
+
+} // namespace Ipopt
+#endif