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

casadi/include/coin-or/IpTNLPReducer.hpp

@@ -0,0 +1,274 @@
+// Copyright (C) 2008 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors:  Andreas Waechter                  IBM    2008-08-10
+
+#ifndef __IPTNLPREDUCER_HPP__
+#define __IPTNLPREDUCER_HPP__
+
+#include "IpTNLP.hpp"
+
+namespace Ipopt
+{
+/** This is a wrapper around a given TNLP class that takes out a
+ *  list of constraints that are given to the constructor.
+ *
+ *  It is provided for convenience, if one wants to experiment with
+ *  problems that consist of only a subset of the constraints.  But
+ *  keep in mind that this is not efficient, since behind the scenes
+ *  we are still evaluation all functions and derivatives, and are
+ *  making copies of the original data.
+ */
+class IPOPTLIB_EXPORT TNLPReducer: public TNLP
+{
+public:
+   /**@name Constructors/Destructors */
+   ///@{
+   /** Constructor is given the indices of the constraints that
+    *  should be taken out of the problem statement, as well as the
+    *  original TNLP.
+    */
+   TNLPReducer(
+      TNLP&        tnlp,
+      Index        n_g_skip,
+      const Index* index_g_skip,
+      Index        n_xL_skip,
+      const Index* index_xL_skip,
+      Index        n_xU_skip,
+      const Index* index_xU_skip,
+      Index        n_x_fix,
+      const Index* index_f_fix
+   );
+
+   /** Default destructor */
+   virtual ~TNLPReducer();
+   ///@}
+
+   /** @name Overloaded methods from TNLP */
+   ///@{
+   virtual bool get_nlp_info(
+      Index&          n,
+      Index&          m,
+      Index&          nnz_jac_g,
+      Index&          nnz_h_lag,
+      IndexStyleEnum& index_style
+   );
+
+   virtual bool get_bounds_info(
+      Index           n,
+      Number*         x_l,
+      Number*         x_u,
+      Index           m,
+      Number*         g_l,
+      Number*         g_u
+   );
+
+   virtual bool get_scaling_parameters(
+      Number&         obj_scaling,
+      bool&           use_x_scaling,
+      Index           n,
+      Number*         x_scaling,
+      bool&           use_g_scaling,
+      Index           m,
+      Number*         g_scaling
+   );
+
+   virtual bool get_variables_linearity(
+      Index          n,
+      LinearityType* var_types
+   );
+
+   virtual bool get_constraints_linearity(
+      Index          m,
+      LinearityType* const_types
+   );
+
+   virtual bool get_starting_point(
+      Index   n,
+      bool    init_x,
+      Number* x,
+      bool    init_z,
+      Number* z_L,
+      Number* z_U,
+      Index   m,
+      bool    init_lambda,
+      Number* lambda
+   );
+
+   virtual bool get_warm_start_iterate(
+      IteratesVector& warm_start_iterate
+   );
+
+   virtual bool eval_f(
+      Index         n,
+      const Number* x,
+      bool          new_x,
+      Number&       obj_value
+   );
+
+   virtual bool eval_grad_f(
+      Index         n,
+      const Number* x,
+      bool          new_x,
+      Number*       grad_f
+   );
+
+   virtual bool eval_g(
+      Index         n,
+      const Number* x,
+      bool          new_x,
+      Index         m,
+      Number*       g
+   );
+
+   virtual bool eval_jac_g(
+      Index         n,
+      const Number* x,
+      bool          new_x,
+      Index         m,
+      Index         nele_jac,
+      Index*        iRow,
+      Index*        jCol,
+      Number*       values
+   );
+
+   virtual bool eval_h(
+      Index         n,
+      const Number* x,
+      bool          new_x,
+      Number        obj_factor,
+      Index         m,
+      const Number* lambda,
+      bool          new_lambda,
+      Index         nele_hess,
+      Index*        iRow,
+      Index*        jCol,
+      Number*       values
+   );
+
+   virtual void finalize_solution(
+      SolverReturn               status,
+      Index                      n,
+      const Number*              x,
+      const Number*              z_L,
+      const Number*              z_U,
+      Index                      m,
+      const Number*              g,
+      const Number*              lambda,
+      Number                     obj_value,
+      const IpoptData*           ip_data,
+      IpoptCalculatedQuantities* ip_cq
+   );
+
+   virtual bool intermediate_callback(
+      AlgorithmMode              mode,
+      Index                      iter,
+      Number                     obj_value,
+      Number                     inf_pr,
+      Number                     inf_du,
+      Number                     mu,
+      Number                     d_norm,
+      Number                     regularization_size,
+      Number                     alpha_du,
+      Number                     alpha_pr,
+      Index                      ls_trials,
+      const IpoptData*           ip_data,
+      IpoptCalculatedQuantities* ip_cq
+   );
+
+   virtual Index get_number_of_nonlinear_variables();
+
+   virtual bool get_list_of_nonlinear_variables(
+      Index  num_nonlin_vars,
+      Index* pos_nonlin_vars
+   );
+   ///@}
+
+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 */
+   TNLPReducer();
+
+   /** Copy Constructor */
+   TNLPReducer(
+      const TNLPReducer&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const TNLPReducer&
+   );
+   ///@}
+
+   /** @name original TNLP */
+   ///@{
+   SmartPtr<TNLP> tnlp_;
+   Index m_orig_;
+   Index nnz_jac_g_orig_;
+   ///@}
+
+   /** Number of constraints to be skipped */
+   Index n_g_skip_;
+
+   /** Array of indices of the constraints that are to be skipped.
+    *
+    *  This is provided at the beginning in the constructor.
+    */
+   Index* index_g_skip_;
+
+   /** Index style for original problem.
+    *
+    * Internally, we use C-Style now.
+    */
+   IndexStyleEnum index_style_orig_;
+
+   /** Map from original constraints to new constraints.
+    *
+    * A -1 means that a constraint is skipped.
+    */
+   Index* g_keep_map_;
+
+   /** Number of constraints in reduced NLP */
+   Index m_reduced_;
+
+   /** Number of Jacobian nonzeros in the reduced NLP */
+   Index nnz_jac_g_reduced_;
+
+   /** Number of Jacobian nonzeros that are skipped */
+   Index nnz_jac_g_skipped_;
+
+   /** Array of Jacobian elements that are to be skipped in increasing order. */
+   Index* jac_g_skipped_;
+
+   /** Number of lower variable bounds to be skipped. */
+   Index n_xL_skip_;
+
+   /** Array of indices of the lower variable bounds to be skipped. */
+   Index* index_xL_skip_;
+
+   /** Number of upper variable bounds to be skipped. */
+   Index n_xU_skip_;
+
+   /** Array of indices of the upper variable bounds to be skipped. */
+   Index* index_xU_skip_;
+
+   /** Number of variables that are to be fixed to initial value. */
+   Index n_x_fix_;
+
+   /** Array of indices of the variables that are to be fixed. */
+   Index* index_x_fix_;
+};
+
+} // namespace Ipopt
+
+#endif

casadi/include/coin-or/IpTaggedObject.hpp

@@ -0,0 +1,128 @@
+// 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 __IPTAGGEDOBJECT_HPP__
+#define __IPTAGGEDOBJECT_HPP__
+
+#include "IpUtils.hpp"
+#include "IpDebug.hpp"
+#include "IpReferenced.hpp"
+#include "IpObserver.hpp"
+
+namespace Ipopt
+{
+
+/** TaggedObject class.
+ * Often, certain calculations or operations are expensive,
+ * and it can be very inefficient to perform these calculations
+ * again if the input to the calculation has not changed
+ * since the result was last stored.
+ * This base class provides an efficient mechanism to update
+ * a tag, indicating that the object has changed.
+ * Users of a TaggedObject class, need their own Tag data
+ * member to keep track of the state of the TaggedObject, the
+ * last time they performed a calculation. A basic use case for
+ * users of a class inheriting from TaggedObject follows like
+ * this:
+ *
+ *  1. Initialize your own Tag to zero in constructor.
+ *
+ *  2. Before an expensive calculation,
+ *      check if the TaggedObject has changed, passing in
+ *      your own Tag, indicating the last time you used
+ *      the object for the calculation. If it has changed,
+ *      perform the calculation again, and store the result.
+ *      If it has not changed, simply return the stored result.
+ *
+ *      Here is a simple example:
+ \verbatim
+        if (vector.HasChanged(my_vector_tag_)) {
+          my_vector_tag_ = vector.GetTag();
+          result = PerformExpensiveCalculation(vector);
+          return result;
+        }
+        else {
+          return result;
+        }
+ \endverbatim
+ *
+ *  Objects derived from TaggedObject must indicate that they have changed to
+ *  the base class using the protected member function ObjectChanged(). For
+ *  example, a Vector class, inside its own set method, MUST call
+ *  ObjectChanged() to update the internally stored tag for comparison.
+ */
+class IPOPTLIB_EXPORT TaggedObject : public ReferencedObject, public Subject
+{
+public:
+   /** Type for the Tag values */
+   typedef unsigned int Tag;
+
+   /** Constructor. */
+   TaggedObject()
+      :
+      Subject()
+   {
+      ObjectChanged();
+   }
+
+   /** Destructor. */
+   virtual ~TaggedObject()
+   {}
+
+   /** Users of TaggedObjects call this to
+    *  update their own internal tags every time
+    *  they perform the expensive operation.
+    */
+   Tag GetTag() const
+   {
+      return tag_;
+   }
+
+   /** Users of TaggedObjects call this to
+    *  check if the object HasChanged since
+    *  they last updated their own internal
+    *  tag.
+    */
+   bool HasChanged(const Tag comparison_tag) const
+   {
+      return (comparison_tag == tag_) ? false : true;
+   }
+protected:
+   /** Objects derived from TaggedObject MUST call this
+    *  method every time their internal state changes to
+    *  update the internal tag for comparison
+    */
+   void ObjectChanged();
+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 */
+   TaggedObject(const TaggedObject&);
+
+   /** Default Assignment Operator */
+   void operator=(const TaggedObject&);
+   ///@}
+
+   /** The tag indicating the current state of the object.
+    *  We use this to compare against the comparison_tag
+    *  in the HasChanged method. This member is updated
+    *  from the unique_tag_ every time the object changes.
+    */
+   Tag tag_;
+
+   /** The index indicating the cache priority for this
+    * TaggedObject. If a result that depended on this
+    * TaggedObject is cached, it will be cached with this
+    * priority
+    */
+   Index cache_priority_;
+};
+} // namespace Ipopt
+#endif

casadi/include/coin-or/IpTimedTask.hpp

@@ -0,0 +1,218 @@
+// Copyright (C) 2006, 2009 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors:  Andreas Waechter               IBM    2005-09-19
+
+#ifndef __IPTIMEDTASK_HPP__
+#define __IPTIMEDTASK_HPP__
+
+#include "IpUtils.hpp"
+
+namespace Ipopt
+{
+/** This class is used to collect timing information for a particular task. */
+class IPOPTLIB_EXPORT TimedTask
+{
+public:
+   /**@name Constructors/Destructors */
+   ///@{
+   /** Default constructor. */
+   TimedTask()
+      :
+      total_cputime_(0.),
+      total_systime_(0.),
+      total_walltime_(0.),
+      enabled_(true),
+      start_called_(false),
+      end_called_(true)
+   {}
+
+   /** Default destructor */
+   ~TimedTask()
+   {}
+   ///@}
+
+   /// enable the timer
+   /// @since 3.14.0
+   void Enable()
+   {
+      enabled_ = true;
+   }
+
+   /// disable the timer
+   ///
+   /// following calls to Start(), End(), and EndIfStarted() have no effect
+   /// @since 3.14.0
+   void Disable()
+   {
+      enabled_ = false;
+   }
+
+   /** Method for resetting time to zero. */
+   void Reset()
+   {
+      total_cputime_ = 0.;
+      total_systime_ = 0.;
+      total_walltime_ = 0.;
+      start_called_ = false;
+      end_called_ = true;
+   }
+
+   /** Method that is called before execution of the task. */
+   void Start()
+   {
+      if( !enabled_ )
+      {
+         return;
+      }
+
+      DBG_ASSERT(end_called_);
+      DBG_ASSERT(!start_called_);
+      end_called_ = false;
+      start_called_ = true;
+      start_cputime_ = CpuTime();
+      start_systime_ = SysTime();
+      start_walltime_ = WallclockTime();
+   }
+
+   /** Method that is called after execution of the task. */
+   void End()
+   {
+      if( !enabled_ )
+      {
+         return;
+      }
+
+      DBG_ASSERT(!end_called_);
+      DBG_ASSERT(start_called_);
+      end_called_ = true;
+      start_called_ = false;
+      total_cputime_ += CpuTime() - start_cputime_;
+      total_systime_ += SysTime() - start_systime_;
+      total_walltime_ += WallclockTime() - start_walltime_;
+   }
+
+   /** Method that is called after execution of the task for which
+    *  timing might have been started.  This only updates the timing
+    *  if the timing has indeed been conducted. This is useful to
+    *  stop timing after catching exceptions. */
+   void EndIfStarted()
+   {
+      if( !enabled_ )
+      {
+         return;
+      }
+      if( start_called_ )
+      {
+         end_called_ = true;
+         start_called_ = false;
+         total_cputime_ += CpuTime() - start_cputime_;
+         total_systime_ += SysTime() - start_systime_;
+         total_walltime_ += WallclockTime() - start_walltime_;
+      }
+      DBG_ASSERT(end_called_);
+   }
+
+   /** Method returning total CPU time spend for task so far. */
+   Number TotalCpuTime() const
+   {
+      DBG_ASSERT(end_called_);
+      return total_cputime_;
+   }
+
+   /** Method returning total system time spend for task so far. */
+   Number TotalSysTime() const
+   {
+      DBG_ASSERT(end_called_);
+      return total_systime_;
+   }
+
+   /** Method returning total wall clock time spend for task so far. */
+   Number TotalWallclockTime() const
+   {
+      DBG_ASSERT(end_called_);
+      return total_walltime_;
+   }
+
+   /** Method returning start CPU time for started task.
+    * @since 3.14.0
+    */
+   Number StartCpuTime() const
+   {
+      DBG_ASSERT(start_called_);
+      DBG_ASSERT(!end_called_);
+      return start_cputime_;
+   }
+
+   /** Method returning start system time for started task.
+    * @since 3.14.0
+    */
+   Number StartSysTime() const
+   {
+      DBG_ASSERT(start_called_);
+      DBG_ASSERT(!end_called_);
+      return start_systime_;
+   }
+
+   /** Method returning start wall clock time for started task.
+    * @since 3.14.0
+    */
+   Number StartWallclockTime() const
+   {
+      DBG_ASSERT(start_called_);
+      DBG_ASSERT(!end_called_);
+      return start_walltime_;
+   }
+
+   /// @since 3.14.0
+   bool IsEnabled() const
+   {
+      return enabled_;
+   }
+
+   /// @since 3.14.0
+   bool IsStarted() const
+   {
+      return start_called_;
+   }
+
+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 */
+   TimedTask(const TimedTask&);
+
+   /** Default Assignment Operator */
+   void operator=(const TimedTask&);
+   ///@}
+
+   /** CPU time at beginning of task. */
+   Number start_cputime_;
+   /** Total CPU time for task measured so far. */
+   Number total_cputime_;
+   /** System time at beginning of task. */
+   Number start_systime_;
+   /** Total system time for task measured so far. */
+   Number total_systime_;
+   /** Wall clock time at beginning of task. */
+   Number start_walltime_;
+   /** Total wall clock time for task measured so far. */
+   Number total_walltime_;
+
+   /** @name status fields */
+   ///@{
+   bool enabled_;
+   bool start_called_;
+   bool end_called_;
+   ///@}
+
+};
+} // namespace Ipopt
+
+#endif