casadi 3.6.4__cp39-none-manylinux2014_i686.whl → 3.6.6__cp39-none-manylinux2014_i686.whl

casadi/include/coin-or/IpAugSystemSolver.hpp

@@ -0,0 +1,212 @@
+// Copyright (C) 2004, 2006 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 __IP_AUGSYSTEMSOLVER_HPP__
+#define __IP_AUGSYSTEMSOLVER_HPP__
+
+#include "IpSymMatrix.hpp"
+#include "IpSymLinearSolver.hpp"
+#include "IpAlgStrategy.hpp"
+
+namespace Ipopt
+{
+DECLARE_STD_EXCEPTION(FATAL_ERROR_IN_LINEAR_SOLVER);
+
+/** Base class for Solver for the augmented system.
+ *
+ *  This is the base class for linear solvers that
+ *  solve the augmented system, which is defined as
+ *
+ *  \f$\left[\begin{array}{cccc}
+ *  W + D_x + \delta_xI & 0 & J_c^T & J_d^T\\
+ *  0 & D_s + \delta_sI & 0 & -I \\
+ *  J_c & 0 & D_c - \delta_cI & 0\\
+ *  J_d & -I & 0 & D_d - \delta_dI
+ *  \end{array}\right]
+ *  \left(\begin{array}{c}sol_x\\sol_s\\sol_c\\sol_d\end{array}\right)=
+ *  \left(\begin{array}{c}rhs_x\\rhs_s\\rhs_c\\rhs_d\end{array}\right)\f$
+ *
+ *  Since this system might be solved repeatedly for different right
+ *  hand sides, it is desirable to step the factorization of a
+ *  direct linear solver if possible.
+ */
+class IPOPTLIB_EXPORT AugSystemSolver: public AlgorithmStrategyObject
+{
+public:
+   /**@name Constructors/Destructors */
+   ///@{
+   /** Default constructor. */
+   AugSystemSolver()
+   { }
+   /** Destructor */
+   virtual ~AugSystemSolver()
+   { }
+   ///@}
+
+   /** overloaded from AlgorithmStrategyObject */
+   virtual bool InitializeImpl(
+      const OptionsList& options,
+      const std::string& prefix
+   ) = 0;
+
+   /** Set up the augmented system and solve it for a given right hand side.
+    *
+    *  If desired (i.e. if check_NegEVals is true), then the
+    *  solution is only computed if the number of negative eigenvalues
+    *  matches numberOfNegEVals.
+    *
+    *  @return return value of the linear solver object.
+    */
+   virtual ESymSolverStatus Solve(
+      const SymMatrix* W,
+      Number           W_factor,
+      const Vector*    D_x,
+      Number           delta_x,
+      const Vector*    D_s,
+      Number           delta_s,
+      const Matrix*    J_c,
+      const Vector*    D_c,
+      Number           delta_c,
+      const Matrix*    J_d,
+      const Vector*    D_d,
+      Number           delta_d,
+      const Vector&    rhs_x,
+      const Vector&    rhs_s,
+      const Vector&    rhs_c,
+      const Vector&    rhs_d,
+      Vector&          sol_x,
+      Vector&          sol_s,
+      Vector&          sol_c,
+      Vector&          sol_d,
+      bool             check_NegEVals,
+      Index            numberOfNegEVals
+   )
+   {
+      std::vector<SmartPtr<const Vector> > rhs_xV(1);
+      rhs_xV[0] = &rhs_x;
+      std::vector<SmartPtr<const Vector> > rhs_sV(1);
+      rhs_sV[0] = &rhs_s;
+      std::vector<SmartPtr<const Vector> > rhs_cV(1);
+      rhs_cV[0] = &rhs_c;
+      std::vector<SmartPtr<const Vector> > rhs_dV(1);
+      rhs_dV[0] = &rhs_d;
+      std::vector<SmartPtr<Vector> > sol_xV(1);
+      sol_xV[0] = &sol_x;
+      std::vector<SmartPtr<Vector> > sol_sV(1);
+      sol_sV[0] = &sol_s;
+      std::vector<SmartPtr<Vector> > sol_cV(1);
+      sol_cV[0] = &sol_c;
+      std::vector<SmartPtr<Vector> > sol_dV(1);
+      sol_dV[0] = &sol_d;
+      return MultiSolve(W, W_factor, D_x, delta_x, D_s, delta_s, J_c, D_c, delta_c, J_d, D_d, delta_d, rhs_xV, rhs_sV,
+                        rhs_cV, rhs_dV, sol_xV, sol_sV, sol_cV, sol_dV, check_NegEVals, numberOfNegEVals);
+   }
+
+   /** Like Solve, but for multiple right hand sides.
+    *
+    *  The inheriting class has to overload at least
+    *  one of Solve and MultiSolve.
+    */
+   virtual ESymSolverStatus MultiSolve(
+      const SymMatrix*                      W,
+      Number                                W_factor,
+      const Vector*                         D_x,
+      Number                                delta_x,
+      const Vector*                         D_s,
+      Number                                delta_s,
+      const Matrix*                         J_c,
+      const Vector*                         D_c,
+      Number                                delta_c,
+      const Matrix*                         J_d,
+      const Vector*                         D_d,
+      Number                                delta_d,
+      std::vector<SmartPtr<const Vector> >& rhs_xV,
+      std::vector<SmartPtr<const Vector> >& rhs_sV,
+      std::vector<SmartPtr<const Vector> >& rhs_cV,
+      std::vector<SmartPtr<const Vector> >& rhs_dV,
+      std::vector<SmartPtr<Vector> >&       sol_xV,
+      std::vector<SmartPtr<Vector> >&       sol_sV,
+      std::vector<SmartPtr<Vector> >&       sol_cV,
+      std::vector<SmartPtr<Vector> >&       sol_dV,
+      bool                                  check_NegEVals,
+      Index                                 numberOfNegEVals
+   )
+   {
+      // Solve for one right hand side after the other
+      Index nrhs = (Index) rhs_xV.size();
+      DBG_ASSERT(nrhs > 0);
+      DBG_ASSERT(nrhs == (Index)rhs_sV.size());
+      DBG_ASSERT(nrhs == (Index)rhs_cV.size());
+      DBG_ASSERT(nrhs == (Index)rhs_dV.size());
+      DBG_ASSERT(nrhs == (Index)sol_xV.size());
+      DBG_ASSERT(nrhs == (Index)sol_sV.size());
+      DBG_ASSERT(nrhs == (Index)sol_cV.size());
+      DBG_ASSERT(nrhs == (Index)sol_dV.size());
+
+      ESymSolverStatus retval = SYMSOLVER_SUCCESS;
+      for( Index i = 0; i < nrhs; i++ )
+      {
+         retval = Solve(W, W_factor, D_x, delta_x, D_s, delta_s, J_c, D_c, delta_c, J_d, D_d, delta_d, *rhs_xV[i],
+                        *rhs_sV[i], *rhs_cV[i], *rhs_dV[i], *sol_xV[i], *sol_sV[i], *sol_cV[i], *sol_dV[i], check_NegEVals,
+                        numberOfNegEVals);
+         if( retval != SYMSOLVER_SUCCESS )
+         {
+            break;
+         }
+      }
+      return retval;
+   }
+
+   /** Number of negative eigenvalues detected during last solve.
+    *
+    * @return number of negative eigenvalues of the most recent factorized matrix
+    * @note This must not be called if the linear solver does not compute this
+    * quantities (see ProvidesInertia).
+    */
+   virtual Index NumberOfNegEVals() const = 0;
+
+   /** Query whether inertia is computed by linear solver.
+    *
+    *  @return true, if linear solver provides inertia
+    */
+   virtual bool ProvidesInertia() const = 0;
+
+   /** Request to increase quality of solution for next solve.
+    *
+    *  Asks underlying linear solver to increase quality of solution for
+    *  the next solve (e.g. increase pivot tolerance).  Returns
+    *  false, if this is not possible (e.g. maximal pivot tolerance
+    *  already used.)
+    */
+   virtual bool IncreaseQuality() = 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.
+    */
+   ///@{
+   /** Copy Constructor */
+   AugSystemSolver(
+      const AugSystemSolver&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const AugSystemSolver&
+   );
+   ///@}
+
+};
+
+} // namespace Ipopt
+
+#endif

casadi/include/coin-or/IpBlas.hpp

@@ -0,0 +1,426 @@
+// Copyright (C) 2004, 2006 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 __IPBLAS_HPP__
+#define __IPBLAS_HPP__
+
+#include "IpUtils.hpp"
+
+namespace Ipopt
+{
+/** Wrapper for BLAS function XDOT.
+ *
+ * Compute dot product of vector x and vector y.
+ * @since 3.14.0
+ */
+IPOPTLIB_EXPORT Number IpBlasDot(
+   Index         size,
+   const Number* x,
+   Index         incX,
+   const Number* y,
+   Index         incY
+);
+
+/** Wrapper for BLAS function DDOT.
+ *
+ * Compute dot product of vector x and vector y.
+ *
+ * @deprecated Use IpBlasDot() instead.
+ */
+IPOPT_DEPRECATED
+inline Number IpBlasDdot(
+   Index         size,
+   const Number* x,
+   Index         incX,
+   const Number* y,
+   Index         incY
+)
+{
+   return IpBlasDot(size, x, incX, y, incY);
+}
+
+/** Wrapper for BLAS function XNRM2.
+ *
+ * Compute 2-norm of vector x.
+ * @since 3.14.0
+ */
+IPOPTLIB_EXPORT Number IpBlasNrm2(
+   Index         size,
+   const Number* x,
+   Index         incX
+);
+
+/** Wrapper for BLAS function DNRM2.
+ *
+ * Compute 2-norm of vector x.
+ *
+ * @deprecated Use IpBlasNrm2() instead.
+ */
+IPOPT_DEPRECATED
+inline Number IpBlasDnrm2(
+   Index         size,
+   const Number* x,
+   Index         incX
+)
+{
+   return IpBlasNrm2(size, x, incX);
+}
+
+/** Wrapper for BLAS function XASUM.
+ *
+ * Compute 1-norm of vector x.
+ * @since 3.14.0
+ */
+IPOPTLIB_EXPORT Number IpBlasAsum(
+   Index         size,
+   const Number* x,
+   Index         incX
+);
+
+/** Wrapper for BLAS function DASUM.
+ *
+ * Compute 1-norm of vector x.
+ *
+ * @deprecated Use IpBlasAsum() instead.
+ */
+IPOPT_DEPRECATED
+inline Number IpBlasDasum(
+   Index         size,
+   const Number* x,
+   Index         incX
+)
+{
+   return IpBlasAsum(size, x, incX);
+}
+
+/** Wrapper for BLAS function IXAMAX.
+ *
+ * Compute index for largest absolute element of vector x.
+ * @since 3.14.0
+ */
+IPOPTLIB_EXPORT Index IpBlasIamax(
+   Index         size,
+   const Number* x,
+   Index         incX
+);
+
+/** Wrapper for BLAS function IDAMAX.
+ *
+ * Compute index for largest absolute element of vector x.
+ *
+ * @deprecated Use IpBlasIamax() instead.
+ */
+IPOPT_DEPRECATED
+inline int IpBlasIdamax(
+   Index         size,
+   const Number* x,
+   Index         incX
+)
+{
+   return (int)IpBlasIamax(size, x, incX);
+}
+
+/** Wrapper for BLAS subroutine XCOPY.
+ *
+ * Copying vector x into vector y.
+ * @since 3.14.0
+ */
+IPOPTLIB_EXPORT void IpBlasCopy(
+   Index         size,
+   const Number* x,
+   Index         incX,
+   Number*       y,
+   Index         incY
+);
+
+/** Wrapper for BLAS subroutine DCOPY.
+ *
+ * Copying vector x into vector y.
+ *
+ * @deprecated Use IpBlasCopy() instead.
+ */
+IPOPT_DEPRECATED
+inline void IpBlasDcopy(
+   Index         size,
+   const Number* x,
+   Index         incX,
+   Number*       y,
+   Index         incY
+)
+{
+   IpBlasCopy(size, x, incX, y, incY);
+}
+
+/** Wrapper for BLAS subroutine XAXPY.
+ *
+ * Adding the alpha multiple of vector x to vector y.
+ * @since 3.14.0
+ */
+IPOPTLIB_EXPORT void IpBlasAxpy(
+   Index         size,
+   Number        alpha,
+   const Number* x,
+   Index         incX,
+   Number*       y,
+   Index         incY
+);
+
+/** Wrapper for BLAS subroutine DAXPY.
+ *
+ * Adding the alpha multiple of vector x to vector y.
+ *
+ * @deprecated Use IpBlasAxpy() instead.
+ */
+IPOPT_DEPRECATED
+inline void IpBlasDaxpy(
+   Index         size,
+   Number        alpha,
+   const Number* x,
+   Index         incX,
+   Number*       y,
+   Index         incY
+)
+{
+   IpBlasAxpy(size, alpha, x, incX, y, incY);
+}
+
+/** Wrapper for BLAS subroutine XSCAL.
+ *
+ * Scaling vector x by scalar alpha.
+ * @since 3.14.0
+ */
+IPOPTLIB_EXPORT void IpBlasScal(
+   Index   size,
+   Number  alpha,
+   Number* x,
+   Index   incX
+);
+
+/** Wrapper for BLAS subroutine DSCAL.
+ *
+ * Scaling vector x by scalar alpha.
+ *
+ * @deprecated Use IpBlasScal() instead.
+ */
+IPOPT_DEPRECATED
+inline void IpBlasDscal(
+   Index   size,
+   Number  alpha,
+   Number* x,
+   Index   incX
+)
+{
+   IpBlasScal(size, alpha, x, incX);
+}
+
+/** Wrapper for BLAS subroutine XGEMV.
+ *
+ * Multiplying a matrix with a vector.
+ * @since 3.14.0
+ */
+IPOPTLIB_EXPORT void IpBlasGemv(
+   bool          trans,
+   Index         nRows,
+   Index         nCols,
+   Number        alpha,
+   const Number* A,
+   Index         ldA,
+   const Number* x,
+   Index         incX,
+   Number        beta,
+   Number*       y,
+   Index         incY
+);
+
+/** Wrapper for BLAS subroutine DGEMV.
+ *
+ * Multiplying a matrix with a vector.
+ *
+ * @deprecated Use IpBlasGemv() instead.
+ */
+IPOPT_DEPRECATED
+inline void IpBlasDgemv(
+   bool          trans,
+   Index         nRows,
+   Index         nCols,
+   Number        alpha,
+   const Number* A,
+   Index         ldA,
+   const Number* x,
+   Index         incX,
+   Number        beta,
+   Number*       y,
+   Index         incY
+)
+{
+   IpBlasGemv(trans, nRows, nCols, alpha, A, ldA, x, incX, beta, y, incY);
+}
+
+/** Wrapper for BLAS subroutine XSYMV.
+ *
+ * Multiplying a symmetric matrix with a vector.
+ * @since 3.14.0
+ */
+IPOPTLIB_EXPORT void IpBlasSymv(
+   Index         n,
+   Number        alpha,
+   const Number* A,
+   Index         ldA,
+   const Number* x,
+   Index         incX,
+   Number        beta,
+   Number*       y,
+   Index         incY
+);
+
+/** Wrapper for BLAS subroutine DSYMV.
+ *
+ * Multiplying a symmetric matrix with a vector.
+ *
+ * @deprecated Use IpBlasSymv() instead.
+ */
+IPOPT_DEPRECATED
+inline void IpBlasDsymv(
+   Index         n,
+   Number        alpha,
+   const Number* A,
+   Index         ldA,
+   const Number* x,
+   Index         incX,
+   Number        beta,
+   Number*       y,
+   Index         incY
+)
+{
+   IpBlasSymv(n, alpha, A, ldA, x, incX, beta, y, incY);
+}
+
+/** Wrapper for BLAS subroutine XGEMM.
+ *
+ * Multiplying two matrices.
+ * @since 3.14.0
+ */
+IPOPTLIB_EXPORT void IpBlasGemm(
+   bool          transa,
+   bool          transb,
+   Index         m,
+   Index         n,
+   Index         k,
+   Number        alpha,
+   const Number* A,
+   Index         ldA,
+   const Number* B,
+   Index         ldB,
+   Number        beta,
+   Number*       C,
+   Index         ldC
+);
+
+/** Wrapper for BLAS subroutine DGEMM.
+ *
+ * Multiplying two matrices.
+ *
+ * @deprecated Use IpBlasGemm() instead.
+ */
+IPOPT_DEPRECATED
+inline void IpBlasDgemm(
+   bool          transa,
+   bool          transb,
+   Index         m,
+   Index         n,
+   Index         k,
+   Number        alpha,
+   const Number* A,
+   Index         ldA,
+   const Number* B,
+   Index         ldB,
+   Number        beta,
+   Number*       C,
+   Index         ldC
+)
+{
+   IpBlasGemm(transa, transb, m, n, k, alpha, A, ldA, B, ldB, beta, C, ldC);
+}
+
+/** Wrapper for BLAS subroutine XSYRK.
+ *
+ * Adding a high-rank update to a matrix.
+ * @since 3.14.0
+ */
+IPOPTLIB_EXPORT void IpBlasSyrk(
+   bool          trans,
+   Index         ndim,
+   Index         nrank,
+   Number        alpha,
+   const Number* A,
+   Index         ldA,
+   Number        beta,
+   Number*       C,
+   Index         ldC
+);
+
+/** Wrapper for BLAS subroutine DSYRK.
+ *
+ * Adding a high-rank update to a matrix.
+ *
+ * @deprecated Use IpBlasSyrk() instead.
+ */
+IPOPT_DEPRECATED
+inline void IpBlasDsyrk(
+   bool          trans,
+   Index         ndim,
+   Index         nrank,
+   Number        alpha,
+   const Number* A,
+   Index         ldA,
+   Number        beta,
+   Number*       C,
+   Index         ldC
+)
+{
+   IpBlasSyrk(trans, ndim, nrank, alpha, A, ldA, beta, C, ldC);
+}
+
+/** Wrapper for BLAS subroutine XTRSM.
+ *
+ * Backsolve for a lower triangular matrix.
+ * @since 3.14.0
+ */
+IPOPTLIB_EXPORT void IpBlasTrsm(
+   bool          trans,
+   Index         ndim,
+   Index         nrhs,
+   Number        alpha,
+   const Number* A,
+   Index         ldA,
+   Number*       B,
+   Index         ldB
+);
+
+/** Wrapper for BLAS subroutine DTRSM.
+ *
+ * Backsolve for a lower triangular matrix.
+ *
+ * @deprecated Use IpBlasTrsm() instead.
+ */
+IPOPT_DEPRECATED
+inline void IpBlasDtrsm(
+   bool          trans,
+   Index         ndim,
+   Index         nrhs,
+   Number        alpha,
+   const Number* A,
+   Index         ldA,
+   Number*       B,
+   Index         ldB
+)
+{
+   IpBlasTrsm(trans, ndim, nrhs, alpha, A, ldA, B, ldB);
+}
+
+} // namespace Ipopt
+
+#endif