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

1 files changed, 130 insertions, 0 deletions

diff --git a/thirdparty/linux/include/coin1/IpPDSystemSolver.hpp b/thirdparty/linux/include/coin1/IpPDSystemSolver.hpp
new file mode 100644
index 0000000..b436e67
--- /dev/null
+++ b/thirdparty/linux/include/coin1/IpPDSystemSolver.hpp
@@ -0,0 +1,130 @@
+// Copyright (C) 2004, 2006 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpPDSystemSolver.hpp 1861 2010-12-21 21:34:47Z andreasw $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPPDSYSTEMSOLVER_HPP__
+#define __IPPDSYSTEMSOLVER_HPP__
+
+#include "IpUtils.hpp"
+#include "IpSymMatrix.hpp"
+#include "IpAlgStrategy.hpp"
+#include "IpIteratesVector.hpp"
+
+namespace Ipopt
+{
+
+  /** Pure Primal Dual System Solver Base Class.
+   *  This is the base class for all derived Primal-Dual System Solver Types.
+   *
+   *  Here, we understand the primal-dual system as the following linear
+   *  system:
+   *
+   *  \f$
+   *  \left[\begin{array}{cccccccc}
+   *  W & 0 & J_c^T & J_d^T & -P^x_L & P^x_U & 0 & 0 \\
+   *  0 & 0 & 0 & -I & 0 & 0 & -P_L^d & P_U^d \\
+   *  J_c & 0 & 0 & 0 & 0 & 0 & 0 & 0\\
+   *  J_d & -I & 0 & 0 & 0 & 0 & 0 & 0\\
+   *  Z_L(P_L^x)^T & 0 & 0 & 0 & Sl^x_L & 0 & 0 & 0\\
+   *  -Z_U(P_U^x)^T & 0 & 0 & 0 & 0 & Sl^x_U & 0 & 0\\
+   *  0 & V_L(P_L^d)^T & 0 & 0 & 0 & 0 & Sl^s_L & 0 \\
+   *  0 & -V_U(P_U^d)^T & 0 & 0 & 0 & 0 & 0 & Sl^s_U \\
+   *  \end{array}\right]
+   *  \left(\begin{array}{c}
+   *  sol_x\\ sol_s\\ sol_c\\ sol_d\\ sol^z_L\\ sol^z_U\\ sol^v_L\\
+   *  sol^v_U
+   *  \end{array}\right) = 
+   *  \left(\begin{array}{c}
+   *  rhs_x\\ rhs_s\\ rhs_c\\ rhs_d\\ rhs^z_L\\ rhs^z_U\\ rhs^v_L\\
+   *  rhs^v_U
+   *  \end{array}\right)
+   *  \f$
+   *
+   *  Here, \f$Sl^x_L = (P^x_L)^T x - x_L\f$, 
+   *  \f$Sl^x_U = x_U - (P^x_U)^T x\f$, \f$Sl^d_L = (P^d_L)^T d(x) - d_L\f$,
+   *  \f$Sl^d_U = d_U - (P^d_U)^T d(x)\f$.  The results returned to the
+   *  caller is \f$res = \alpha * sol + \beta * res\f$.
+   *
+   *  The solution of this linear system (in order to compute the search
+   *  direction of the algorthim) usually requires a considerable amount of
+   *  computation time.  Therefore, it is important to tailor the solution
+   *  of this system to the characteristics of the problem.  The purpose of
+   *  this base class is to provide a generic interface to the algorithm
+   *  that it can use whenever it requires a solution of the above system.
+   *  Particular implementation can then be written to provide the methods
+   *  defined here.
+   *
+   *  It is implicitly assumed here, that the upper left 2 by 2 block
+   *  is possibly modified (implicitly or explicitly) so that its
+   *  projection onto the null space of the overall constraint
+   *  Jacobian \f$\left[\begin{array}{cc}J_c & 0\\J_d &
+   *  -I\end{array}\right]\f$ is positive definite.  This is necessary
+   *  to guarantee certain descent properties of the resulting search
+   *  direction.  For example, in the full space implementation, a
+   *  multiple of the identity might be added to the upper left 2 by 2
+   *  block.
+   *
+   *  Note that the Solve method might be called several times for different
+   *  right hand sides, but with identical data.  Therefore, if possible,
+   *  an implemetation of PDSystem should check whether the incoming data has
+   *  changed, and not redo factorization etc. unless necessary.
+   */
+  class PDSystemSolver: public AlgorithmStrategyObject
+  {
+  public:
+    /** @name /Destructor */
+    //@{
+    /** Default Constructor */
+    PDSystemSolver()
+    {}
+
+    /** Default destructor */
+    virtual ~PDSystemSolver()
+    {}
+    //@}
+
+    /** overloaded from AlgorithmStrategyObject */
+    virtual bool InitializeImpl(const OptionsList& options,
+                                const std::string& prefix) = 0;
+
+    /** Solve the primal dual system, given one right hand side.  If
+     *  the flag allow_inexact is set to true, it is not necessary to
+     *  solve the system to best accuracy; for example, we don't want
+     *  iterative refinement during the computation of the second
+     *  order correction.  On the other hand, if improve_solution is
+     *  true, the solution given in res should be improved (here beta
+     *  has to be zero, and res is assume to be the solution for the
+     *  system using rhs, without the factor alpha...).  THe return
+     *  value is false, if a solution could not be computed (for
+     *  example, when the Hessian regularization parameter becomes too
+     *  large.)
+     */
+    virtual bool Solve(Number alpha,
+                       Number beta,
+                       const IteratesVector& rhs,
+                       IteratesVector& res,
+                       bool allow_inexact=false,
+                       bool improve_solution=false) =0;
+
+  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. */
+    //@{
+    /** Overloaded Equals Operator */
+    PDSystemSolver& operator=(const PDSystemSolver&);
+    //@}
+  };
+
+
+} // namespace Ipopt
+
+#endif