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

casadi/include/coin-or/IpReturnCodes.h

@@ -0,0 +1,23 @@
+/* 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 __IPRETURNCODES_H__
+#define __IPRETURNCODES_H__
+
+/* include from a common include file */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include "IpReturnCodes_inc.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

casadi/include/coin-or/IpReturnCodes.hpp

@@ -0,0 +1,18 @@
+/* Copyright (C) 2006 International Business Machines and others.
+ * All Rights Reserved.
+ * This code is published under the Eclipse Public License.
+ *
+ * Authors:  Andreas Waechter               IBM    2006-03-01
+ */
+
+#ifndef __IPRETURNCODES_HPP__
+#define __IPRETURNCODES_HPP__
+
+/* include from a common include file */
+
+namespace Ipopt
+{
+#include "IpReturnCodes_inc.h"
+}
+
+#endif

casadi/include/coin-or/IpReturnCodes.inc

@@ -0,0 +1,71 @@
+C Copyright (C) 2005, 2009 International Business Machines and others.
+C All Rights Reserved.
+C This code is published under the Eclipse Public License.
+C
+C Author:   Andreas Waechter    IBM      2005-08-11
+C
+      INTEGER IP_SOLVE_SUCCEEDED
+      PARAMETER( IP_SOLVE_SUCCEEDED = 0 )
+
+      INTEGER IP_ACCEPTABLE_LEVEL
+      PARAMETER( IP_ACCEPTABLE_LEVEL = 1 )
+
+      INTEGER IP_INFEASIBLE_PROBLEM
+      PARAMETER( IP_INFEASIBLE_PROBLEM = 2 )
+
+      INTEGER IP_SEARCH_DIRECTION_TOO_SMALL
+      PARAMETER( IP_SEARCH_DIRECTION_TOO_SMALL = 3 )
+
+      INTEGER IP_DIVERGING_ITERATES
+      PARAMETER( IP_DIVERGING_ITERATES = 4 )
+
+      INTEGER IP_USER_REQUESTED_STOP
+      PARAMETER( IP_USER_REQUESTED_STOP = 5 )
+
+      INTEGER IP_FEASIBLE_POINT_FOUND
+      PARAMETER( IP_FEASIBLE_POINT_FOUND = 6 )
+
+      INTEGER IP_ITERATION_EXCEEDED
+      PARAMETER( IP_ITERATION_EXCEEDED = -1 )
+
+      INTEGER IP_RESTORATION_FAILED
+      PARAMETER( IP_RESTORATION_FAILED = -2 )
+
+      INTEGER IP_ERROR_IN_STEP_COMPUTATION
+      PARAMETER( IP_ERROR_IN_STEP_COMPUTATION = -3 )
+
+      INTEGER IP_CPUTIME_EXCEEDED
+      PARAMETER( IP_CPUTIME_EXCEEDED = -4 )
+
+      INTEGER IP_WALLTIME_EXCEEDED
+      PARAMETER( IP_WALLTIME_EXCEEDED = -5 )
+
+      INTEGER IP_NOT_ENOUGH_DEGREES_OF_FRE
+      PARAMETER( IP_NOT_ENOUGH_DEGREES_OF_FRE = -10 )
+
+      INTEGER IP_INVALID_PROBLEM_DEFINITION
+      PARAMETER( IP_INVALID_PROBLEM_DEFINITION = -11)
+
+      INTEGER IP_INVALID_OPTION
+      PARAMETER( IP_INVALID_OPTION = -12 )
+
+      INTEGER IP_INVALID_NUMBER_DETECTED
+      PARAMETER( IP_INVALID_NUMBER_DETECTED = -13 )
+
+      INTEGER IP_UNRECOVERABLE_EXCEPTION
+      PARAMETER( IP_UNRECOVERABLE_EXCEPTION = -100 )
+
+      INTEGER IP_NON_IPOPT_EXCEPTION
+      PARAMETER( IP_NON_IPOPT_EXCEPTION = -101 )
+
+      INTEGER IP_INSUFFICIENT_MEMORY
+      PARAMETER( IP_INSUFFICIENT_MEMORY = -102 )
+
+      INTEGER IP_INTERNAL_ERROR
+      PARAMETER( IP_INTERNAL_ERROR = -199 )
+
+      INTEGER IP_REGULAR_MODE
+      PARAMETER( IP_REGULAR_MODE = 0 )
+
+      INTEGER IP_RESTORATION_PHASE_MODE
+      PARAMETER( IP_RESTORATION_PHASE_MODE = 1 )

casadi/include/coin-or/IpReturnCodes_inc.h

@@ -0,0 +1,45 @@
+/* Copyright (C) 2004, 2009 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
+ */
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
+/* !!!!!!!!! REMEMBER TO UPDATE IpReturnCodes.inc and Ipopt.java !!!!!!!! */
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
+
+/** Return codes for the Optimize call for an application */
+enum ApplicationReturnStatus
+{
+   Solve_Succeeded                    = 0,
+   Solved_To_Acceptable_Level         = 1,
+   Infeasible_Problem_Detected        = 2,
+   Search_Direction_Becomes_Too_Small = 3,
+   Diverging_Iterates                 = 4,
+   User_Requested_Stop                = 5,
+   Feasible_Point_Found               = 6,
+
+   Maximum_Iterations_Exceeded        = -1,
+   Restoration_Failed                 = -2,
+   Error_In_Step_Computation          = -3,
+   Maximum_CpuTime_Exceeded           = -4,
+   Maximum_WallTime_Exceeded          = -5,   ///< @since 3.14.0
+
+   Not_Enough_Degrees_Of_Freedom      = -10,
+   Invalid_Problem_Definition         = -11,
+   Invalid_Option                     = -12,
+   Invalid_Number_Detected            = -13,
+
+   Unrecoverable_Exception            = -100,
+   NonIpopt_Exception_Thrown          = -101,
+   Insufficient_Memory                = -102,
+   Internal_Error                     = -199
+};
+
+/** enum to indicate the mode in which the algorithm is */
+enum AlgorithmMode
+{
+   RegularMode          = 0,
+   RestorationPhaseMode = 1
+};

casadi/include/coin-or/IpScaledMatrix.hpp

@@ -0,0 +1,291 @@
+// 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 __IPSCALEDMATRIX_HPP__
+#define __IPSCALEDMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpMatrix.hpp"
+
+namespace Ipopt
+{
+
+/* forward declarations */
+class ScaledMatrixSpace;
+
+/** 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 ScaledMatrix: public Matrix
+{
+public:
+   /**@name Constructors / Destructors */
+   ///@{
+   /** Constructor, taking the owner_space.
+    */
+   ScaledMatrix(
+      const ScaledMatrixSpace* owner_space
+   );
+
+   /** Destructor */
+   ~ScaledMatrix();
+   ///@}
+
+   /** Set the unscaled matrix */
+   void SetUnscaledMatrix(
+      const SmartPtr<const Matrix> unscaled_matrix
+   );
+
+   /** Set the unscaled matrix in a non-const version */
+   void SetUnscaledMatrixNonConst(
+      const SmartPtr<Matrix>& unscaled_matrix
+   );
+
+   /** Return the unscaled matrix in const form */
+   SmartPtr<const Matrix> GetUnscaledMatrix() const;
+
+   /** Return the unscaled matrix in non-const form */
+   SmartPtr<Matrix> GetUnscaledMatrixNonConst();
+
+   /** return the vector for the row scaling */
+   SmartPtr<const Vector> RowScaling() const;
+
+   /** return the vector for the column scaling */
+   SmartPtr<const Vector> ColumnScaling() 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;
+
+   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;
+
+   /** X = beta*X + alpha*(Matrix S^{-1} Z). */
+   // ToDo Specialized implementation missing so far!
+   virtual void AddMSinvZImpl(
+      Number        alpha,
+      const Vector& S,
+      const Vector& Z,
+      Vector&       X
+   ) const;
+
+   /** X = S^{-1} (r + alpha*Z*M^Td). */
+   // ToDo Specialized implementation missing so far!
+   virtual void SinvBlrmZMTdBrImpl(
+      Number        alpha,
+      const Vector& S,
+      const Vector& R,
+      const Vector& Z,
+      const Vector& D,
+      Vector&       X
+   ) 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 */
+   ScaledMatrix();
+
+   /** Copy Constructor */
+   ScaledMatrix(
+      const ScaledMatrix&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const ScaledMatrix&
+   );
+   ///@}
+
+   /** const version of the unscaled matrix */
+   SmartPtr<const Matrix> matrix_;
+
+   /** non-const version of the unscaled matrix */
+   SmartPtr<Matrix> nonconst_matrix_;
+
+   /** Matrix space stored as a ScaledMatrixSpace */
+   SmartPtr<const ScaledMatrixSpace> owner_space_;
+};
+
+/** This is the matrix space for ScaledMatrix. */
+class IPOPTLIB_EXPORT ScaledMatrixSpace: 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.
+    */
+   ScaledMatrixSpace(
+      const SmartPtr<const Vector>&      row_scaling,
+      bool                               row_scaling_reciprocal,
+      const SmartPtr<const MatrixSpace>& unscaled_matrix_space,
+      const SmartPtr<const Vector>&      column_scaling,
+      bool                               column_scaling_reciprocal
+   );
+
+   /** Destructor */
+   ~ScaledMatrixSpace()
+   { }
+   ///@}
+
+   /** Method for creating a new matrix of this specific type. */
+   ScaledMatrix* MakeNewScaledMatrix(
+      bool allocate_unscaled_matrix = false
+   ) const
+   {
+      ScaledMatrix* ret = new ScaledMatrix(this);
+      if( allocate_unscaled_matrix )
+      {
+         SmartPtr<Matrix> unscaled_matrix = unscaled_matrix_space_->MakeNew();
+         ret->SetUnscaledMatrixNonConst(unscaled_matrix);
+      }
+      return ret;
+   }
+
+   virtual Matrix* MakeNew() const
+   {
+      return MakeNewScaledMatrix();
+   }
+
+   /** return the vector for the row scaling */
+   SmartPtr<const Vector> RowScaling() const
+   {
+      return ConstPtr(row_scaling_);
+   }
+
+   /** return the matrix space for the unscaled matrix */
+   SmartPtr<const MatrixSpace> UnscaledMatrixSpace() const
+   {
+      return unscaled_matrix_space_;
+   }
+
+   /** return the vector for the column scaling */
+   SmartPtr<const Vector> ColumnScaling() const
+   {
+      return ConstPtr(column_scaling_);
+   }
+
+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 */
+   ScaledMatrixSpace();
+
+   /** Copy Constructor */
+   ScaledMatrixSpace(
+      const ScaledMatrixSpace&
+   );
+
+   /** Default Assignment Operator */
+   ScaledMatrixSpace& operator=(
+      const ScaledMatrixSpace&
+   );
+   ///@}
+
+   /** Row scaling vector */
+   SmartPtr<Vector> row_scaling_;
+
+   /** unscaled matrix space */
+   SmartPtr<const MatrixSpace> unscaled_matrix_space_;
+
+   /** column scaling vector */
+   SmartPtr<Vector> column_scaling_;
+};
+
+inline void ScaledMatrix::SetUnscaledMatrix(
+   const SmartPtr<const Matrix> unscaled_matrix
+)
+{
+   matrix_ = unscaled_matrix;
+   nonconst_matrix_ = NULL;
+   ObjectChanged();
+}
+
+inline void ScaledMatrix::SetUnscaledMatrixNonConst(
+   const SmartPtr<Matrix>& unscaled_matrix
+)
+{
+   nonconst_matrix_ = unscaled_matrix;
+   matrix_ = GetRawPtr(unscaled_matrix);
+   ObjectChanged();
+}
+
+inline SmartPtr<const Matrix> ScaledMatrix::GetUnscaledMatrix() const
+{
+   return matrix_;
+}
+
+inline SmartPtr<Matrix> ScaledMatrix::GetUnscaledMatrixNonConst()
+{
+   DBG_ASSERT(IsValid(nonconst_matrix_));
+   ObjectChanged();
+   return nonconst_matrix_;
+}
+
+inline SmartPtr<const Vector> ScaledMatrix::RowScaling() const
+{
+   return ConstPtr(owner_space_->RowScaling());
+}
+
+inline SmartPtr<const Vector> ScaledMatrix::ColumnScaling() const
+{
+   return ConstPtr(owner_space_->ColumnScaling());
+}
+
+} // namespace Ipopt
+
+#endif

casadi/include/coin-or/IpSearchDirCalculator.hpp

@@ -0,0 +1,72 @@
+// Copyright (C) 2005, 2007 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors:  Andreas Waechter            IBM    2005-10-13
+
+#ifndef __IPSEARCHDIRCALCULATOR_HPP__
+#define __IPSEARCHDIRCALCULATOR_HPP__
+
+#include "IpAlgStrategy.hpp"
+
+namespace Ipopt
+{
+
+/** Base class for computing the search direction for the line
+ *  search.
+ */
+class IPOPTLIB_EXPORT SearchDirectionCalculator: public AlgorithmStrategyObject
+{
+public:
+   /**@name Constructors/Destructors */
+   ///@{
+   /** Constructor */
+   SearchDirectionCalculator()
+   { }
+
+   /** Destructor */
+   virtual ~SearchDirectionCalculator()
+   { }
+   ///@}
+
+   virtual bool InitializeImpl(
+      const OptionsList& options,
+      const std::string& prefix
+   ) = 0;
+
+   /** Pure virtual method for computing the search direction.
+    *
+    *  The computed direction is stored in IpData().delta().
+    */
+   virtual bool ComputeSearchDirection() = 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.
+    */
+   ///@{
+   /** Default Constructor */
+   //    SearchDirectionCalculator();
+
+   /** Copy Constructor */
+   SearchDirectionCalculator(
+      const SearchDirectionCalculator&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const SearchDirectionCalculator&
+   );
+   ///@}
+
+};
+
+} // namespace Ipopt
+
+#endif