casadi 3.6.7__cp38-none-manylinux2014_i686.whl → 3.7.1__cp38-none-manylinux2014_i686.whl

casadi/include/casadi/core/shared_object.hpp

@@ -26,27 +26,21 @@
 #ifndef CASADI_SHARED_OBJECT_HPP
 #define CASADI_SHARED_OBJECT_HPP
 
-#include "casadi_common.hpp"
-#include "exception.hpp"
-#include <map>
-#include <vector>
+#include "generic_shared_internal.hpp"
 
 namespace casadi {
 
-  // Forward declaration of weak reference class
-  class WeakRef;
-
   /// \cond INTERNAL
   // Forward declaration of internal classes
   class SharedObjectInternal;
   class WeakRefInternal;
   /// \endcond
 
-  /** \brief SharedObject implements a reference counting framework similar for efficient and
+  /** \brief GenericShared implements a reference counting framework similar for efficient and 
 
       easily-maintained memory management.
 
-      To use the class, both the SharedObject class (the public class), and the SharedObjectInternal
+      To use the class, both the GenericShared class (the public class), and the GenericSharedInternal
       class (the internal class) must be inherited from. It can be done in two different files
       and together with memory management, this approach provides a clear distinction of which
       methods of the class are to be considered "public", i.e. methods for public use that can
@@ -81,190 +75,108 @@ namespace casadi {
       \date 2010
 
       \identifier{as} */
-  class CASADI_EXPORT SharedObject {
-#ifndef SWIG
-    template<class B> friend B shared_cast(SharedObject& A);
-    template<class B> friend const B shared_cast(const SharedObject& A);
-#endif // SWIG
-
-  public:
-#ifndef SWIG
-    /// Default constructor
-    SharedObject();
-
-    /// Copy constructor (shallow copy)
-    SharedObject(const SharedObject& ref);
+  class CASADI_EXPORT SharedObject :
+      public GenericShared<SharedObject, SharedObjectInternal> {
+    public:
 
-    /// Destructor
-    ~SharedObject();
+      /** \brief Get class name
 
-    /// Assignment operator
-    SharedObject& operator=(const SharedObject& ref);
+          \identifier{au} */
+      std::string class_name() const;
 
-    /// \cond INTERNAL
-    /// Assign the node to a node class pointer (or null)
-    void own(SharedObjectInternal* node);
+      /// Print a description of the object
+      void disp(std::ostream& stream, bool more=false) const;
 
-    /** \brief Assign the node to a node class pointer without reference counting
-     *
-     * improper use will cause memory leaks!
+      /// Get string representation
+      std::string get_str(bool more=false) const {
+        std::stringstream ss;
+        disp(ss, more);
+        return ss.str();
+      }
 
-        \identifier{at} */
-    void assign(SharedObjectInternal* node);
+      /// \cond INTERNAL
+      /// Print the pointer to the internal class
+      void print_ptr(std::ostream &stream=casadi::uout()) const;
+      /// \endcond
 
-    /// Get a const pointer to the node
-    SharedObjectInternal* get() const;
+      using internal_base_type = SharedObjectInternal;
+      using base_type = SharedObject;
 
-    /// Get the reference count
-    casadi_int getCount() const;
-
-    /// Swap content with another instance
-    void swap(SharedObject& other);
-
-    /// Access a member function or object
-    SharedObjectInternal* operator->() const;
-    /// \endcond
-#endif // SWIG
-
-    /** \brief Get class name
-
-        \identifier{au} */
-    std::string class_name() const;
-
-    /// Print a description of the object
-    void disp(std::ostream& stream, bool more=false) const;
-
-    /// Get string representation
-    std::string get_str(bool more=false) const {
-      std::stringstream ss;
-      disp(ss, more);
-      return ss.str();
-    }
-
-    /// \cond INTERNAL
-    /// Print the pointer to the internal class
-    void print_ptr(std::ostream &stream=casadi::uout()) const;
-    /// \endcond
-
-    /// Is a null pointer?
-    bool is_null() const;
-
-    /** \brief Returns a number that is unique for a given Node.
-
-     * If the Object does not point to any node, "0" is returned.
-
-        \identifier{av} */
-    casadi_int __hash__() const;
-
-/// \cond INTERNAL
-#ifndef SWIG
-    /** \brief Get a weak reference to the object
-
-        \identifier{aw} */
-    WeakRef* weak();
-  protected:
-    void count_up(); // increase counter of the node
-    void count_down(); // decrease counter of the node
-  private:
-    SharedObjectInternal *node;
-#endif // SWIG
-/// \endcond
   };
 
 /** \brief Weak reference type
 
-    A weak reference to a SharedObject
+    A weak reference to a GenericShared
     \author Joel Andersson
     \date 2013
 
     \identifier{ax} */
-  class CASADI_EXPORT WeakRef : public SharedObject {
+  class CASADI_EXPORT WeakRef :
+      public GenericWeakRef<SharedObject, SharedObjectInternal> {
   public:
-    friend class SharedObjectInternal;
-
-    /** \brief Default constructor
-
-        \identifier{ay} */
-    WeakRef(int dummy=0);
-
-    /** \brief Construct from a shared object (also implicit type conversion)
-
-        \identifier{az} */
-    WeakRef(SharedObject shared);
-
-    /** \brief Get a shared (owning) reference
-
-        \identifier{b0} */
-    SharedObject shared();
-
-    /** \brief Check if alive
-
-        \identifier{b1} */
-    bool alive() const;
-
-    /** \brief  Access functions of the node
-
-        \identifier{b2} */
-    WeakRefInternal* operator->();
-
-    /** \brief  Const access functions of the node
-
-        \identifier{b3} */
-    const WeakRefInternal* operator->() const;
-
-#ifndef SWIG
-  private:
-    /** \brief Construct from a shared object (internal)
-
-        \identifier{b4} */
-    explicit WeakRef(SharedObjectInternal* raw);
-
-    /** \brief The shared object has been deleted
-
-        \identifier{b5} */
-    void kill();
-#endif // SWIG
+    WeakRef(int dummy=0) : GenericWeakRef<SharedObject, SharedObjectInternal>(dummy) {
+    }
+    WeakRef(SharedObject shared) : GenericWeakRef<SharedObject, SharedObjectInternal>(shared) {
+    }
+  /*private:
+    explicit WeakRef(SharedObjectInternal* raw) : GenericWeakRef<SharedObject, SharedObjectInternal>(raw) {
+    };*/
   };
 
 #ifndef SWIG
+  class CASADI_EXPORT SharedObjectInternal :
+    public GenericSharedInternal<SharedObject, SharedObjectInternal> {
+    friend class GenericShared<SharedObject, SharedObjectInternal>;
+    friend class SharedObject;
+    friend class GenericWeakRef<SharedObject, SharedObjectInternal>;
+    friend class GenericSharedInternal<SharedObject, SharedObjectInternal>;
+    friend class Memory;
+    friend class UniversalNodeOwner;
+  public:
+    /// NOTE: these two constructors added because defaults are ill-formed defaults
+    /// This may hint at a bug
+    /// Default constructor
+    SharedObjectInternal() : GenericSharedInternal<SharedObject, SharedObjectInternal>() {
+    }
+    /// Copy constructor
+    SharedObjectInternal(const SharedObjectInternal& node) :
+      GenericSharedInternal<SharedObject, SharedObjectInternal>(node) {
+    }
 
-  /** \brief Typecast a shared object to a base class to a shared object to a derived class,
+    /// Readable name of the internal class
+    virtual std::string class_name() const = 0;
 
-   * cf. dynamic_cast
+    /// Print a description of the object
+    virtual void disp(std::ostream& stream, bool more) const = 0;
 
-      \identifier{b6} */
-  template<class B>
-  B shared_cast(SharedObject& A) {
+    using weak_ref_type = WeakRefInternal;
 
-    /// Get a pointer to the node
-    SharedObjectInternal* ptr = A.get();
+  private:
+    /// Number of references pointing to the object
+#ifdef CASADI_WITH_THREAD
+    std::atomic<casadi_int> count;
+#else // CASADI_WITH_THREAD
+    casadi_int count;
+#endif
 
-    /// Create a return object
-    B ret;
+  };
 
-    /// Quick return if not allowed
-    if (!B::test_cast(ptr)) return ret;
+  class CASADI_EXPORT WeakRefInternal :
+      public GenericWeakRefInternal<SharedObject, SharedObjectInternal> {
+    public:
+      /// Print a description of the object
+    void disp(std::ostream& stream, bool more) const override;
 
-    /// Assign node of B and return
-    ret.own(ptr);
-    return ret;
-  }
+    /// Readable name of the class
+    std::string class_name() const override {return "WeakRefInternal";}
 
-  /** \brief Typecast a shared object to a base class to a shared object to a derived class,
+    using GenericWeakRefInternal<SharedObject, SharedObjectInternal>::GenericWeakRefInternal;
 
-   * cf. dynamic_cast (const)
+  };
 
-      \identifier{b7} */
-  template<class B>
-  const B shared_cast(const SharedObject& A) {
-    SharedObject A_copy = A;
-    return shared_cast<B>(A_copy);
-  }
 
 #endif // SWIG
 
-
 } // namespace casadi
 
-
 #endif // CASADI_SHARED_OBJECT_HPP

casadi/include/casadi/core/sparsity.hpp

@@ -36,6 +36,13 @@
 #include <list>
 #include <limits>
 #include <unordered_map>
+#ifdef CASADI_WITH_THREAD
+#ifdef CASADI_WITH_THREAD_MINGW
+#include <mingw.mutex.h>
+#else // CASADI_WITH_THREAD_MINGW
+#include <mutex>
+#endif // CASADI_WITH_THREAD_MINGW
+#endif //CASADI_WITH_THREAD
 
 namespace casadi {
   // Forward declaration
@@ -269,7 +276,7 @@ namespace casadi {
     Sparsity get_diag(std::vector<casadi_int>& SWIG_OUTPUT(mapping)) const;
 
     /// Compress a sparsity pattern
-    std::vector<casadi_int> compress() const;
+    std::vector<casadi_int> compress(bool canonical=true) const;
 
 #ifndef SWIG
     /// Access a member function or object
@@ -876,6 +883,11 @@ namespace casadi {
     /// Cached sparsity patterns
     static CachingMap& getCache();
 
+#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
+    // Safe access to CachingMap
+    static std::mutex cachingmap_mtx;
+#endif //CASADI_WITH_THREADSAFE_SYMBOLICS
+
     /// (Dense) scalar
     static const Sparsity& getScalar();
 

casadi/include/casadi/core/sparsity_interface.hpp

@@ -590,7 +590,25 @@ namespace casadi {
         \identifier{4q} */
     inline friend MatType sum2(const MatType &x) { return MatType::sum2(x);}
 
-/** \@} */
+    /** \brief Returns summation of all elements
+
+        \identifier{2d6} */
+    inline friend MatType sum(const MatType &x) {
+      if (x.is_vector()) {
+        if (x.is_column()) {
+          return MatType::sum1(x);
+        } else {
+          return MatType::sum2(x);
+        }
+      }
+      if (x.size1()>x.size2()) {
+        return MatType::sum2(MatType::sum1(x));
+      } else {
+        return MatType::sum1(MatType::sum2(x));
+      }
+    }
+
+    /** \@} */
   };
 #endif // SWIG
 

casadi/include/casadi/core/sx.hpp

@@ -64,6 +64,27 @@ template<> inline std::string matrixName<SXElem>() { return "SX"; }
   template<>
   bool SX::is_symbolic() const;
 
+  template<>
+  bool SX::is_call() const;
+
+  template<>
+  std::vector<SXElem> SX::call(const Function& f, const std::vector<SXElem>& dep);
+
+  template<>
+  bool SX::is_output() const;
+
+  template<>
+  bool SX::has_output() const;
+
+  template<>
+  SX SX::get_output(casadi_int oind) const;
+
+  template<>
+  Function SX::which_function() const;
+
+  template<>
+  casadi_int SX::which_output() const;
+
   template<>
   casadi_int SX::op() const;
 
@@ -109,12 +130,28 @@ template<> inline std::string matrixName<SXElem>() { return "SX"; }
   void SX::substitute_inplace(const std::vector<SX>& v, std::vector<SX>& vdef,
                              std::vector<SX>& ex, bool reverse);
 
+  template<>
+  void SX::extract_parametric(const SX &expr, const SX& par,
+      SX& expr_ret, std::vector<SX>& symbols, std::vector<SX>& parametric,
+      const Dict& opts);
+
+  template<>
+  void SX::separate_linear(const SX &expr,
+    const SX &sym_lin, const SX &sym_const,
+    SX& expr_const, SX& expr_lin, SX& expr_nonlin);
+
   template<>
   std::vector<SX> SX::cse(const std::vector<SX>& e);
 
   template<>
   bool SX::depends_on(const SX &x, const SX &arg);
 
+  template<>
+  bool SX::contains_all(const std::vector<SX>& v, const std::vector<SX> &n);
+
+  template<>
+  bool SX::contains_any(const std::vector<SX>& v, const std::vector<SX> &n);
+
   template<>
   SX SX::jacobian(const SX &f, const SX &x, const Dict& opts);
   template<>
@@ -192,6 +229,10 @@ template<> inline std::string matrixName<SXElem>() { return "SX"; }
   void CASADI_EXPORT SX::to_file(const std::string& filename, const Sparsity& sp,
     const SXElem* nonzeros, const std::string& format_hint);
 
+#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
+  template<>
+  std::mutex& SX::get_mutex_temp();
+#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
 
 #ifndef CASADI_SX_INSTANTIATOR_CPP
   extern template class Matrix<SXElem>;

casadi/include/casadi/core/sx_elem.hpp

@@ -44,6 +44,15 @@
 #include <string>
 #include <vector>
 
+#ifdef CASADI_WITH_THREAD
+#include <atomic>
+#ifdef CASADI_WITH_THREAD_MINGW
+#include <mingw.mutex.h>
+#else // CASADI_WITH_THREAD_MINGW
+#include <mutex>
+#endif // CASADI_WITH_THREAD_MINGW
+#endif //CASADI_WITH_THREAD
+
 namespace casadi {
 
   /** \brief  forward declaration of Node and Matrix
@@ -147,6 +156,7 @@ namespace casadi {
         \identifier{10p} */
     static SXElem binary(casadi_int op, const SXElem& x, const SXElem& y);
     static SXElem unary(casadi_int op, const SXElem& x);
+    static std::vector<SXElem> call(const Function& f, const std::vector<SXElem>& deps);
 
     /** \brief Check the truth value of this node
 
@@ -178,6 +188,11 @@ namespace casadi {
     const std::string& name() const;
     casadi_int op() const;
     bool is_op(casadi_int op) const;
+    bool is_call() const;
+    bool is_output() const;
+    bool has_output() const;
+    Function which_function() const;
+    casadi_int which_output() const;
 
     /// Checks if expression does not contain NaN or Inf
     bool is_regular() const;
@@ -204,6 +219,11 @@ namespace casadi {
         \identifier{10v} */
     casadi_int n_dep() const;
 
+    /** \brief  Get an output
+
+        \identifier{29f} */
+    SXElem get_output(casadi_int oind) const;
+
     /** \brief Returns a number that is unique for a given SXNode.
 
      * If the SXElem does not point to any node, 0 is returned.
@@ -272,6 +292,11 @@ namespace casadi {
     void serialize(SerializingStream& s) const;
 
     static SXElem deserialize(DeserializingStream& s);
+
+#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
+    static std::mutex mutex_temp;
+#endif //CASADI_WITH_THREADSAFE_SYMBOLICS
+
   private:
     /// Pointer to node (SXElem is only a reference class)
     SXNode* node;

casadi/include/casadi/core/xml_node.hpp

@@ -175,6 +175,11 @@ struct CASADI_EXPORT XmlNode {
       \identifier{vr} */
   static void read(const std::string& str, casadi_int* val);
 
+  /** \brief  Read the size_t value of a string
+
+      \identifier{29u} */
+  static void read(const std::string& str, size_t* val);
+
   /** \brief  Read the double value of a string
 
       \identifier{vs} */