casadi 3.6.4__cp312-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/include/coin-or/IpPDSystemSolver.hpp

@@ -0,0 +1,137 @@
+// 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 __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 algorithm) 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 implementation of PDSystem should check whether the incoming data has
+ *  changed, and not redo factorization etc. unless necessary.
+ */
+class IPOPTLIB_EXPORT PDSystemSolver: public AlgorithmStrategyObject
+{
+public:
+   /** @name Constructor/Destructor */
+   ///@{
+   /** Default Constructor */
+   PDSystemSolver()
+   { }
+
+   /** 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...).
+    *
+    *  @return 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.
+    */
+   ///@{
+   /** Default Assignment Operator */
+   PDSystemSolver& operator=(
+      const PDSystemSolver&
+   );
+   ///@}
+};
+
+} // namespace Ipopt
+
+#endif

casadi/include/include/coin-or/IpReferenced.hpp

@@ -0,0 +1,262 @@
+// 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 __IPREFERENCED_HPP__
+#define __IPREFERENCED_HPP__
+
+#include "IpTypes.hpp"
+#include "IpDebug.hpp"
+
+#include <list>
+
+#if IPOPT_CHECKLEVEL > 3
+#define IP_DEBUG_REFERENCED
+#endif
+
+namespace Ipopt
+{
+
+/** Pseudo-class, from which everything has to inherit that wants to
+ *  use be registered as a Referencer for a ReferencedObject.
+ */
+class Referencer { };
+
+/** Storing the reference count of all the smart pointers that currently reference it.
+ *
+ * This is part of the implementation of an intrusive smart pointer
+ * design.  See the documentation for the SmartPtr class for more details.
+ *
+ * A SmartPtr behaves much like a raw pointer, but manages the lifetime
+ * of an object, deleting the object automatically. This class implements
+ * a reference-counting, intrusive smart pointer design, where all
+ * objects pointed to must inherit off of ReferencedObject, which
+ * stores the reference count. Although this is intrusive (native types
+ * and externally authored classes require wrappers to be referenced
+ * by smart pointers), it is a safer design. A more detailed discussion of
+ * these issues follows after the usage information.
+ *
+ * Usage Example:
+ * Note: to use the SmartPtr, all objects to which you point MUST
+ * inherit off of ReferencedObject.
+ *
+ * \verbatim
+ *
+ * In MyClass.hpp...
+ *
+ * #include "IpReferenced.hpp"
+
+ * namespace Ipopt {
+ *
+ *  class MyClass : public ReferencedObject // must derive from ReferencedObject
+ *    {
+ *      ...
+ *    }
+ * } // namespace Ipopt
+ *
+ *
+ * In my_usage.cpp...
+ *
+ * #include "IpSmartPtr.hpp"
+ * #include "MyClass.hpp"
+ *
+ * void func(AnyObject& obj)
+ *  {
+ *    SmartPtr<MyClass> ptr_to_myclass = new MyClass(...);
+ *    // ptr_to_myclass now points to a new MyClass,
+ *    // and the reference count is 1
+ *
+ *    ...
+ *
+ *    obj.SetMyClass(ptr_to_myclass);
+ *    // Here, let's assume that AnyObject uses a
+ *    // SmartPtr<MyClass> internally here.
+ *    // Now, both ptr_to_myclass and the internal
+ *    // SmartPtr in obj point to the same MyClass object
+ *    // and its reference count is 2.
+ *
+ *    ...
+ *
+ *    // No need to delete ptr_to_myclass, this
+ *    // will be done automatically when the
+ *    // reference count drops to zero.
+ *
+ *  }
+ *
+ * \endverbatim
+ *
+ * Other Notes:
+ *  The SmartPtr implements both dereference operators -> & *.
+ *  The SmartPtr does NOT implement a conversion operator to
+ *    the raw pointer. Use the GetRawPtr() method when this
+ *    is necessary. Make sure that the raw pointer is NOT
+ *    deleted.
+ *  The SmartPtr implements the comparison operators == & !=
+ *    for a variety of types. Use these instead of
+ *    \verbatim
+ *    if (GetRawPtr(smrt_ptr) == ptr) // Don't use this
+ *    \endverbatim
+ *  SmartPtr's, as currently implemented, do NOT handle circular references.
+ *    For example: consider a higher level object using SmartPtrs to point to
+ *    A and B, but A and B also point to each other (i.e. A has a SmartPtr
+ *    to B and B has a SmartPtr to A). In this scenario, when the higher
+ *    level object is finished with A and B, their reference counts will
+ *    never drop to zero (since they reference each other) and they
+ *    will not be deleted. This can be detected by memory leak tools like
+ *    valgrind. If the circular reference is necessary, the problem can be
+ *    overcome by a number of techniques:
+ *
+ *    1) A and B can have a method that "releases" each other, that is
+ *        they set their internal SmartPtrs to NULL.
+ *        \verbatim
+ *        void AClass::ReleaseCircularReferences()
+ *          {
+ *          smart_ptr_to_B = NULL;
+ *          }
+ *        \endverbatim
+ *        Then, the higher level class can call these methods before
+ *        it is done using A & B.
+ *
+ *    2) Raw pointers can be used in A and B to reference each other.
+ *        Here, an implicit assumption is made that the lifetime is
+ *        controlled by the higher level object and that A and B will
+ *        both exist in a controlled manner. Although this seems
+ *        dangerous, in many situations, this type of referencing
+ *        is very controlled and this is reasonably safe.
+ *
+ *    3) This SmartPtr class could be redesigned with the Weak/Strong
+ *        design concept. Here, the SmartPtr is identified as being
+ *        Strong (controls lifetime of the object) or Weak (merely
+ *        referencing the object). The Strong SmartPtr increments
+ *        (and decrements) the reference count in ReferencedObject
+ *        but the Weak SmartPtr does not. In the example above,
+ *        the higher level object would have Strong SmartPtrs to
+ *        A and B, but A and B would have Weak SmartPtrs to each
+ *        other. Then, when the higher level object was done with
+ *        A and B, they would be deleted. The Weak SmartPtrs in A
+ *        and B would not decrement the reference count and would,
+ *        of course, not delete the object. This idea is very similar
+ *        to item (2), where it is implied that the sequence of events
+ *        is controlled such that A and B will not call anything using
+ *        their pointers following the higher level delete (i.e. in
+ *        their destructors!). This is somehow safer, however, because
+ *        code can be written (however expensive) to perform run-time
+ *        detection of this situation. For example, the ReferencedObject
+ *        could store pointers to all Weak SmartPtrs that are referencing
+ *        it and, in its destructor, tell these pointers that it is
+ *        dying. They could then set themselves to NULL, or set an
+ *        internal flag to detect usage past this point.
+ *
+ *   For every most derived object only one ReferencedObject may exist,
+ *   that is multiple inheritance requires virtual inheritance, see also
+ *   the 2nd point in ticket #162.
+ *
+ * Comments on Non-Intrusive Design:
+ * In a non-intrusive design, the reference count is stored somewhere other
+ * than the object being referenced. This means, unless the reference
+ * counting pointer is the first referencer, it must get a pointer to the
+ * referenced object from another smart pointer (so it has access to the
+ * reference count location). In this non-intrusive design, if we are
+ * pointing to an object with a smart pointer (or a number of smart
+ * pointers), and we then give another smart pointer the address through
+ * a RAW pointer, we will have two independent, AND INCORRECT, reference
+ * counts. To avoid this pitfall, we use an intrusive reference counting
+ * technique where the reference count is stored in the object being
+ * referenced.
+ */
+class IPOPTLIB_EXPORT ReferencedObject
+{
+public:
+   ReferencedObject()
+      : reference_count_(0)
+   { }
+
+   virtual ~ReferencedObject()
+   {
+      DBG_ASSERT(reference_count_ == 0);
+   }
+
+   inline Index ReferenceCount() const;
+
+   inline
+   void AddRef(
+      const Referencer* referencer
+   ) const;
+
+   inline
+   void ReleaseRef(
+      const Referencer* referencer
+   ) const;
+
+private:
+   mutable Index reference_count_;
+
+#   ifdef IP_DEBUG_REFERENCED
+   mutable std::list<const Referencer*> referencers_;
+#   endif
+
+};
+
+/* inline methods */
+inline Index ReferencedObject::ReferenceCount() const
+{
+   //    DBG_START_METH("ReferencedObject::ReferenceCount()", 0);
+   //    DBG_PRINT((1,"Returning reference_count_ = %" IPOPT_INDEX_FORMAT "\n", reference_count_));
+   return reference_count_;
+}
+
+inline
+void ReferencedObject::AddRef(
+   const Referencer* referencer
+) const
+{
+   //    DBG_START_METH("ReferencedObject::AddRef(const Referencer* referencer)", 0);
+   reference_count_++;
+   //    DBG_PRINT((1, "New reference_count_ = %" IPOPT_INDEX_FORMAT "\n", reference_count_));
+#   ifdef IP_DEBUG_REFERENCED
+   referencers_.push_back(referencer);
+#   else
+   (void) referencer;
+#   endif
+}
+
+inline
+void ReferencedObject::ReleaseRef(
+   const Referencer* referencer
+) const
+{
+   //    DBG_START_METH("ReferencedObject::ReleaseRef(const Referencer* referencer)",
+   //                   0);
+   reference_count_--;
+   //    DBG_PRINT((1, "New reference_count_ = %" IPOPT_INDEX_FORMAT "\n", reference_count_));
+
+#   ifdef IP_DEBUG_REFERENCED
+
+   bool found = false;
+   std::list<const Referencer*>::iterator iter;
+   for( iter = referencers_.begin(); iter != referencers_.end(); ++iter )
+   {
+      if ((*iter) == referencer)
+      {
+         found = true;
+         break;
+      }
+   }
+
+   // cannot call release on a reference that was never added...
+   DBG_ASSERT(found);
+
+   if (found)
+   {
+      referencers_.erase(iter);
+   }
+#   else
+   (void) referencer;
+#   endif
+}
+
+} // namespace Ipopt
+
+#endif