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

casadi/include/coin-or/IpSymLinearSolver.hpp

@@ -0,0 +1,141 @@
+// 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 __IPSYMLINEARSOLVER_HPP__
+#define __IPSYMLINEARSOLVER_HPP__
+
+#include "IpUtils.hpp"
+#include "IpSymMatrix.hpp"
+#include "IpAlgStrategy.hpp"
+#include <vector>
+
+namespace Ipopt
+{
+
+/** Enum to report outcome of a linear solve */
+enum ESymSolverStatus
+{
+   /** Successful solve */
+   SYMSOLVER_SUCCESS,
+   /** Matrix seems to be singular; solve was aborted */
+   SYMSOLVER_SINGULAR,
+   /** The number of negative eigenvalues is not correct */
+   SYMSOLVER_WRONG_INERTIA,
+   /** Call the solver interface again after the matrix values have been restored */
+   SYMSOLVER_CALL_AGAIN,
+   /** Unrecoverable error in linear solver occurred.
+    *  The optimization will be aborted.
+    */
+   SYMSOLVER_FATAL_ERROR
+};
+
+/** Base class for all derived symmetric linear solvers.
+ *
+ *  In the full space version of Ipopt a large linear
+ *  system has to be solved for the augmented system.  This case is
+ *  meant to be the base class for all derived linear solvers for
+ *  symmetric matrices (of type SymMatrix).
+ *
+ *  A linear solver can be used repeatedly for matrices with
+ *  identical structure of nonzero elements.  The nonzero structure
+ *  of those matrices must not be changed between calls.
+ *
+ *  The called might ask the solver to only solve the linear system
+ *  if the system is nonsingular, and if the number of negative
+ *  eigenvalues matches a given number.
+ */
+class IPOPTLIB_EXPORT SymLinearSolver: public AlgorithmStrategyObject
+{
+public:
+   /** @name Constructor/Destructor */
+   ///@{
+   SymLinearSolver()
+   { }
+
+   virtual ~SymLinearSolver()
+   { }
+   ///@}
+
+   virtual bool InitializeImpl(
+      const OptionsList& options,
+      const std::string& prefix
+   ) = 0;
+
+   /** @name Methods for requesting solution of the linear system. */
+   ///@{
+   /** Solve operation for multiple right hand sides.
+    *
+    *  Solves the linear system A * Sol = Rhs with multiple right hand sides.
+    *  If necessary, A is factorized.  Correct solutions are only
+    *  guaranteed if the return values is SYMSOLVER_SUCCESS.  The
+    *  solver will return SYMSOLVER_SINGULAR if the linear system is
+    *  singular, and it will return SYMSOLVER_WRONG_INERTIA if
+    *  check_NegEVals is true and the number of negative eigenvalues
+    *  in the matrix does not match numberOfNegEVals.
+    *
+    *  check_NegEVals cannot be chosen true, if ProvidesInertia()
+    *  returns false.
+    */
+   virtual ESymSolverStatus MultiSolve(
+      const SymMatrix&                      A,
+      std::vector<SmartPtr<const Vector> >& rhsV,
+      std::vector<SmartPtr<Vector> >&       solV,
+      bool                                  check_NegEVals,
+      Index                                 numberOfNegEVals
+   ) = 0;
+
+   /** Solve operation for a single right hand side.
+    *
+    *  Solves the linear system A * Sol = Rhs.
+    *  See MultiSolve for more details.
+    */
+   ESymSolverStatus Solve(
+      const SymMatrix& A,
+      const Vector&    rhs,
+      Vector&          sol,
+      bool             check_NegEVals,
+      Index            numberOfNegEVals
+   )
+   {
+      std::vector<SmartPtr<const Vector> > rhsV(1);
+      rhsV[0] = &rhs;
+      std::vector<SmartPtr<Vector> > solV(1);
+      solV[0] = &sol;
+      return MultiSolve(A, rhsV, solV, check_NegEVals, numberOfNegEVals);
+   }
+
+   /** Number of negative eigenvalues detected during last factorization.
+    *
+    *  @return the number of negative eigenvalues of the most recent factorized matrix
+    *
+    *  This must not be called if the linear solver does not compute this quantities
+    *  (see ProvidesInertia).
+    */
+   virtual Index NumberOfNegEVals() const = 0;
+   ///@}
+
+   //* @name Options of Linear solver */
+   ///@{
+   /** Request to increase quality of solution for next solve.
+    *
+    * Ask linear solver to increase quality of solution for the next
+    * solve (e.g. increase pivot tolerance).
+    *
+    * @return false, if this is not possible, e.g. maximal pivot tolerance already used.
+    */
+   virtual bool IncreaseQuality() = 0;
+
+   /** Query whether inertia is computed by linear solver.
+    *
+    * @return true, if linear solver provides inertia
+    */
+   virtual bool ProvidesInertia() const = 0;
+   ///@}
+};
+
+} // namespace Ipopt
+
+#endif

casadi/include/coin-or/IpSymMatrix.hpp

@@ -0,0 +1,167 @@
+// Copyright (C) 2004, 2008 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 __IPSYMMATRIX_HPP__
+#define __IPSYMMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpMatrix.hpp"
+
+namespace Ipopt
+{
+
+/* forward declarations */
+class SymMatrixSpace;
+
+/** This is the base class for all derived symmetric matrix types. */
+class IPOPTLIB_EXPORT SymMatrix: public Matrix
+{
+public:
+   /** @name Constructor/Destructor */
+   ///@{
+   /** Constructor, taking the owner_space.
+    */
+   inline SymMatrix(
+      const SymMatrixSpace* owner_space
+   );
+
+   /** Destructor */
+   virtual ~SymMatrix()
+   { }
+   ///@}
+
+   /** @name Information about the size of the matrix */
+   ///@{
+   /** Dimension of the matrix (number of rows and columns) */
+   inline Index Dim() const;
+   ///@}
+
+   inline SmartPtr<const SymMatrixSpace> OwnerSymMatrixSpace() const;
+
+protected:
+   /** @name Overloaded methods from Matrix. */
+   ///@{
+   /** Implementation of TransMultVectorImpl, which calls MultVectorImpl.
+    *
+    *  Since the matrix is symmetric, it is only necessary to implement the
+    *  MultVectorImpl method in a class that inherits from this base
+    *  class.
+    */
+   virtual void TransMultVectorImpl(
+      Number        alpha,
+      const Vector& x,
+      Number        beta,
+      Vector&       y
+   ) const
+   {
+      // Since this matrix is symmetric, this is the same operation as MultVector
+      MultVector(alpha, x, beta, y);
+   }
+
+   /** Implementation of ComputeColAMaxImpl, which calls ComputeRowAMaxImpl.
+    *
+    * Since the matrix is symmetric, the row and column max norms are identical.
+    */
+   virtual void ComputeColAMaxImpl(
+      Vector& cols_norms,
+      bool    init
+   ) const
+   {
+      ComputeRowAMaxImpl(cols_norms, init);
+   }
+   ///@}
+
+private:
+   /** Copy of the owner space ptr as a SymMatrixSpace instead
+    *  of a MatrixSpace
+    */
+   const SymMatrixSpace* owner_space_;
+};
+
+/** SymMatrixSpace base class, corresponding to the SymMatrix base class. */
+class IPOPTLIB_EXPORT SymMatrixSpace: public MatrixSpace
+{
+public:
+   /** @name Constructors/Destructors */
+   ///@{
+   /** Constructor, given the dimension (identical to the number of
+    *  rows and columns).
+    */
+   SymMatrixSpace(
+      Index dim
+   )
+      : MatrixSpace(dim, dim)
+   { }
+
+   /** Destructor */
+   virtual ~SymMatrixSpace()
+   { }
+   ///@}
+
+   /** Pure virtual method for creating a new matrix of this specific type. */
+   virtual SymMatrix* MakeNewSymMatrix() const = 0;
+
+   virtual Matrix* MakeNew() const
+   {
+      return MakeNewSymMatrix();
+   }
+
+   /** Accessor method for the dimension of the matrices in this
+    *  matrix space.
+    */
+   Index Dim() const
+   {
+      DBG_ASSERT(NRows() == NCols());
+      return NRows();
+   }
+
+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 */
+   SymMatrixSpace();
+
+   /* Copy constructor */
+   SymMatrixSpace(
+      const SymMatrixSpace&
+   );
+
+   /** Default Assignment Operator */
+   SymMatrixSpace& operator=(
+      const SymMatrixSpace&
+   );
+   ///@}
+
+};
+
+/* inline methods */
+inline SymMatrix::SymMatrix(
+   const SymMatrixSpace* owner_space
+)
+   : Matrix(owner_space),
+     owner_space_(owner_space)
+{ }
+
+inline Index SymMatrix::Dim() const
+{
+   return owner_space_->Dim();
+}
+
+inline SmartPtr<const SymMatrixSpace> SymMatrix::OwnerSymMatrixSpace() const
+{
+   return owner_space_;
+}
+
+} // namespace Ipopt
+
+#endif

casadi/include/coin-or/IpSymScaledMatrix.hpp

@@ -0,0 +1,255 @@
+// Copyright (C) 2004, 2008 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 __IPSYMSCALEDMATRIX_HPP__
+#define __IPSYMSCALEDMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpSymMatrix.hpp"
+
+namespace Ipopt
+{
+
+/* forward declarations */
+class SymScaledMatrixSpace;
+
+/** Class for a Matrix in conjunction with its scaling factors for
+ *  row and column scaling.
+ *
+ *  Operations on the matrix are performed using
+ *  the scaled matrix. You can pull out the pointer to the
+ *  unscaled matrix for unscaled calculations.
+ */
+class IPOPTLIB_EXPORT SymScaledMatrix: public SymMatrix
+{
+public:
+   /**@name Constructors / Destructors */
+   ///@{
+   /** Constructor, taking the owner_space.
+    */
+   SymScaledMatrix(
+      const SymScaledMatrixSpace* owner_space
+   );
+
+   /** Destructor */
+   ~SymScaledMatrix();
+   ///@}
+
+   /** Set the unscaled matrix */
+   void SetUnscaledMatrix(
+      const SmartPtr<const SymMatrix> unscaled_matrix
+   );
+
+   /** Set the unscaled matrix in a non-const version */
+   void SetUnscaledMatrixNonConst(
+      const SmartPtr<SymMatrix>& unscaled_matrix
+   );
+
+   /** Return the unscaled matrix in const form */
+   SmartPtr<const SymMatrix> GetUnscaledMatrix() const;
+
+   /** Return the unscaled matrix in non-const form */
+   SmartPtr<SymMatrix> GetUnscaledMatrixNonConst();
+
+   /** return the vector for the row and column scaling */
+   SmartPtr<const Vector> RowColScaling() const;
+
+protected:
+   /**@name Methods overloaded from Matrix */
+   ///@{
+   virtual void MultVectorImpl(
+      Number        alpha,
+      const Vector& x,
+      Number        beta,
+      Vector&       y
+   ) const;
+
+   virtual bool HasValidNumbersImpl() const;
+
+   virtual void ComputeRowAMaxImpl(
+      Vector& rows_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 */
+   SymScaledMatrix();
+
+   /** Copy Constructor */
+   SymScaledMatrix(
+      const SymScaledMatrix&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const SymScaledMatrix&
+   );
+   ///@}
+
+   /** const version of the unscaled matrix */
+   SmartPtr<const SymMatrix> matrix_;
+
+   /** non-const version of the unscaled matrix */
+   SmartPtr<SymMatrix> nonconst_matrix_;
+
+   /** Matrix space stored as a SymScaledMatrixSpace */
+   SmartPtr<const SymScaledMatrixSpace> owner_space_;
+};
+
+/** This is the matrix space for SymScaledMatrix.
+ */
+class IPOPTLIB_EXPORT SymScaledMatrixSpace: public SymMatrixSpace
+{
+public:
+   /** @name Constructors / Destructors */
+   ///@{
+   /** Constructor, given the number of row and columns blocks, as
+    *  well as the total number of rows and columns.
+    */
+   SymScaledMatrixSpace(
+      const SmartPtr<const Vector>&         row_col_scaling,
+      bool                                  row_col_scaling_reciprocal,
+      const SmartPtr<const SymMatrixSpace>& unscaled_matrix_space
+   )
+      : SymMatrixSpace(unscaled_matrix_space->Dim()),
+        scaling_(row_col_scaling->MakeNewCopy()),
+        unscaled_matrix_space_(unscaled_matrix_space)
+   {
+      if( row_col_scaling_reciprocal )
+      {
+         scaling_->ElementWiseReciprocal();
+      }
+   }
+
+   /** Destructor */
+   ~SymScaledMatrixSpace()
+   { }
+   ///@}
+
+   /** Method for creating a new matrix of this specific type. */
+   SymScaledMatrix* MakeNewSymScaledMatrix(
+      bool allocate_unscaled_matrix = false
+   ) const
+   {
+      SymScaledMatrix* ret = new SymScaledMatrix(this);
+      if( allocate_unscaled_matrix )
+      {
+         SmartPtr<SymMatrix> unscaled_matrix = unscaled_matrix_space_->MakeNewSymMatrix();
+         ret->SetUnscaledMatrixNonConst(unscaled_matrix);
+      }
+      return ret;
+   }
+
+   virtual SymMatrix* MakeNewSymMatrix() const
+   {
+      return MakeNewSymScaledMatrix();
+   }
+
+   virtual Matrix* MakeNew() const
+   {
+      return MakeNewSymScaledMatrix();
+   }
+
+   /** return the vector for the row and column scaling */
+   SmartPtr<const Vector> RowColScaling() const
+   {
+      return ConstPtr(scaling_);
+   }
+
+   /** return the matrix space for the unscaled matrix */
+   SmartPtr<const SymMatrixSpace> UnscaledMatrixSpace() const
+   {
+      return unscaled_matrix_space_;
+   }
+
+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 */
+   SymScaledMatrixSpace();
+
+   /** Copy Constructor */
+   SymScaledMatrixSpace(
+      const SymScaledMatrixSpace&
+   );
+
+   /** Default Assignment Operator */
+   SymScaledMatrixSpace& operator=(
+      const SymScaledMatrixSpace&
+   );
+   ///@}
+
+   /** Row scaling vector */
+   SmartPtr<Vector> scaling_;
+
+   /** unscaled matrix space */
+   SmartPtr<const SymMatrixSpace> unscaled_matrix_space_;
+};
+
+inline void SymScaledMatrix::SetUnscaledMatrix(
+   const SmartPtr<const SymMatrix> unscaled_matrix
+)
+{
+   matrix_ = unscaled_matrix;
+   nonconst_matrix_ = NULL;
+   ObjectChanged();
+}
+
+inline void SymScaledMatrix::SetUnscaledMatrixNonConst(
+   const SmartPtr<SymMatrix>& unscaled_matrix
+)
+{
+   nonconst_matrix_ = unscaled_matrix;
+   matrix_ = GetRawPtr(unscaled_matrix);
+   ObjectChanged();
+}
+
+inline SmartPtr<const SymMatrix> SymScaledMatrix::GetUnscaledMatrix() const
+{
+   return matrix_;
+}
+
+inline SmartPtr<SymMatrix> SymScaledMatrix::GetUnscaledMatrixNonConst()
+{
+   DBG_ASSERT(IsValid(nonconst_matrix_));
+   ObjectChanged();
+   return nonconst_matrix_;
+}
+
+inline SmartPtr<const Vector> SymScaledMatrix::RowColScaling() const
+{
+   return ConstPtr(owner_space_->RowColScaling());
+}
+
+} // namespace Ipopt
+
+#endif