casadi 3.6.7__cp310-none-manylinux2014_x86_64.whl → 3.7.0__cp310-none-manylinux2014_x86_64.whl

casadi/include/casadi/core/runtime/casadi_blazing_de_boor.hpp

@@ -0,0 +1,101 @@
+//
+//    MIT No Attribution
+//
+//    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl, KU Leuven.
+//
+//    Permission is hereby granted, free of charge, to any person obtaining a copy of this
+//    software and associated documentation files (the "Software"), to deal in the Software
+//    without restriction, including without limitation the rights to use, copy, modify,
+//    merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so.
+//
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+//    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+// SYMBOL "blazing_printvec"
+template<typename T1>
+void casadi_blazing_printvec(const simde__m256d* e) {
+  double elements[4];
+  simde_mm256_storeu_pd(elements, *e);
+  printf("mm256d: <%.4f %.4f %.4f %.4f>\n", elements[0], elements[1], elements[2], elements[3]);
+}
+
+// SYMBOL "blazing_de_boor"
+template<typename T1>
+void casadi_blazing_de_boor(T1 x, const T1* knots, simde__m256d* boor_d0, simde__m256d* boor_d1, simde__m256d* boor_d2, const simde__m256d* boor_d3) { // NOLINT(whitespace/line_length)
+  simde__m256d x_ = simde_mm256_set1_pd(x);
+  simde__m256d zero = simde_mm256_set1_pd(0.0);
+  simde__m256d mask_end = simde_mm256_set_pd(0.0, -1.0, -1.0, -1.0);
+
+  // shift one up
+  simde__m256d boor_d3i_1 = simde_mm256_permute4x64_pd(*boor_d3, SIMDE_MM_SHUFFLE(3, 3, 2, 1));
+  boor_d3i_1 = simde_mm256_blendv_pd(zero, boor_d3i_1, mask_end);
+
+  simde__m256d knotsi = simde_mm256_loadu_pd(knots);
+  simde__m256d knotsi_1 = simde_mm256_loadu_pd(knots+1);
+  simde__m256d knotsi_2 = simde_mm256_loadu_pd(knots+2);
+  simde__m256d knotsi_3 = simde_mm256_loadu_pd(knots+3);
+  simde__m256d knotsi_4 = simde_mm256_loadu_pd(knots+4);
+
+  simde__m256d bottom = simde_mm256_sub_pd(knotsi_1, knotsi); // bottom = knots[i + 1] - knots[i];
+  simde__m256d bottom_mask = simde_mm256_cmp_pd(bottom, zero, SIMDE_CMP_EQ_OQ); // if (bottom)
+
+  // (x - knots[i]) / bottom;
+  simde__m256d r = simde_mm256_div_pd(simde_mm256_sub_pd(x_, knotsi), bottom);
+  r = simde_mm256_blendv_pd(r, zero, bottom_mask);
+  *boor_d2 = simde_mm256_mul_pd(r, *boor_d3);
+
+  *boor_d2 = simde_mm256_blendv_pd(*boor_d2, zero, bottom_mask);
+
+  bottom = simde_mm256_sub_pd(knotsi_2, knotsi_1); // bottom = knots[i + 2] - knots[i + 1];
+  bottom_mask = simde_mm256_cmp_pd(bottom, zero, SIMDE_CMP_EQ_OQ);
+  r = simde_mm256_div_pd(simde_mm256_sub_pd(knotsi_2, x_), bottom); // (knots[i + 2] - x) / bottom
+  r = simde_mm256_blendv_pd(r, zero, bottom_mask);
+
+  *boor_d2 = simde_mm256_fmadd_pd(r, boor_d3i_1, *boor_d2);
+
+  // shift one up
+  simde__m256d boor_d2i_1 = simde_mm256_permute4x64_pd(*boor_d2, SIMDE_MM_SHUFFLE(3, 3, 2, 1));
+  boor_d2i_1 = simde_mm256_blendv_pd(zero, boor_d2i_1, mask_end);
+
+  bottom = simde_mm256_sub_pd(knotsi_2, knotsi); // bottom = knots[i + 2] - knots[i];
+  bottom_mask = simde_mm256_cmp_pd(bottom, zero, SIMDE_CMP_EQ_OQ); // if (bottom)
+
+  r = simde_mm256_div_pd(simde_mm256_sub_pd(x_, knotsi), bottom); // (x - knots[i]) / bottom;
+  r = simde_mm256_blendv_pd(r, zero, bottom_mask);
+  *boor_d1 = simde_mm256_mul_pd(r, *boor_d2);
+
+  *boor_d1 = simde_mm256_blendv_pd(*boor_d1, zero, bottom_mask);
+
+  bottom = simde_mm256_sub_pd(knotsi_3, knotsi_1); // bottom = knots[i + 3] - knots[i + 1];
+  bottom_mask = simde_mm256_cmp_pd(bottom, zero, SIMDE_CMP_EQ_OQ);
+  r = simde_mm256_div_pd(simde_mm256_sub_pd(knotsi_3, x_), bottom);  // (knots[i + 3] - x) / bottom
+  r = simde_mm256_blendv_pd(r, zero, bottom_mask);
+
+  *boor_d1 = simde_mm256_fmadd_pd(r, boor_d2i_1, *boor_d1);
+
+  // shift one up
+  simde__m256d boor_d1i_1 = simde_mm256_permute4x64_pd(*boor_d1, SIMDE_MM_SHUFFLE(3, 3, 2, 1));
+  boor_d1i_1 = simde_mm256_blendv_pd(zero, boor_d1i_1, mask_end);
+
+  bottom = simde_mm256_sub_pd(knotsi_3, knotsi); // bottom = knots[i + 3] - knots[i];
+  bottom_mask = simde_mm256_cmp_pd(bottom, zero, SIMDE_CMP_EQ_OQ); // if (bottom)
+
+  r = simde_mm256_div_pd(simde_mm256_sub_pd(x_, knotsi), bottom); // (x - knots[i]) / bottom;
+  r = simde_mm256_blendv_pd(r, zero, bottom_mask);
+  *boor_d0 = simde_mm256_mul_pd(r, *boor_d1);
+
+  *boor_d0 = simde_mm256_blendv_pd(*boor_d0, zero, bottom_mask);
+
+  bottom = simde_mm256_sub_pd(knotsi_4, knotsi_1); // bottom = knots[i + 4] - knots[i + 1];
+  bottom_mask = simde_mm256_cmp_pd(bottom, zero, SIMDE_CMP_EQ_OQ);
+  r = simde_mm256_div_pd(simde_mm256_sub_pd(knotsi_4, x_), bottom);  // (knots[i + 4] - x) / bottom
+  r = simde_mm256_blendv_pd(r, zero, bottom_mask);
+
+  *boor_d0 = simde_mm256_fmadd_pd(r, boor_d1i_1, *boor_d0);
+}

casadi/include/casadi/core/runtime/casadi_nlp.hpp

@@ -161,7 +161,8 @@ int casadi_detect_bounds_before(casadi_nlpsol_data<T1>* d_nlp) {
   const casadi_nlpsol_detect_bounds_prob<T1>* p_bounds = &p_nlp->detect_bounds;
 
   casadi_int nx = p_nlp->nx;
-  d_bounds->arg[0] = d_nlp->p;
+  d_bounds->arg[0] = d_nlp->z;
+  d_bounds->arg[1] = d_nlp->p;
   d_bounds->res[0] = d_bounds->a;
   d_bounds->res[1] = d_bounds->b;
   p_bounds->callback(d_bounds->arg, d_bounds->res,
@@ -203,6 +204,8 @@ int casadi_detect_bounds_before(casadi_nlpsol_data<T1>* d_nlp) {
         ub = tmp;
       }
       casadi_int j = p_bounds->target_x[k];
+      lb += d_nlp->z[j];
+      ub += d_nlp->z[j];
 
       if (lb==d_nlp->lbz[j]) {
         if (d_nlp->lam_g0) d_bounds->lam_xl[j] += (d_nlp->lam_g0[i]<0)*d_nlp->lam_g0[i];
@@ -253,7 +256,10 @@ int casadi_detect_bounds_after(casadi_nlpsol_data<T1>* d_nlp) {
   for (casadi_int i=0;i<p_bounds->ng;++i) {
     if (p_bounds->is_simple[i]) {
       casadi_int j = p_bounds->target_x[k];
-      if (d_nlp->g) d_nlp->g[i] = d_bounds->a[k]*d_nlp->z[j]+d_bounds->b[k];
+      if (d_nlp->g) {
+        d_nlp->g[i] = d_bounds->a[k]*d_nlp->z[j]-d_bounds->b[k];
+        if (d_nlp->x0) d_nlp->g[i] += d_nlp->x0[j];
+      }
       k++;
     } else {
       if (d_nlp->g) d_nlp->g[i] = d_nlp->z[nx+k_normal];

casadi/include/casadi/core/runtime/casadi_printme.hpp

@@ -0,0 +1,25 @@
+//
+//    MIT No Attribution
+//
+//    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl, KU Leuven.
+//
+//    Permission is hereby granted, free of charge, to any person obtaining a copy of this
+//    software and associated documentation files (the "Software"), to deal in the Software
+//    without restriction, including without limitation the rights to use, copy, modify,
+//    merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so.
+//
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+//    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+// SYMBOL "printme"
+template<typename T1>
+T1 casadi_printme(T1 a, T1 b) {
+  printf("|> %.15g : %.15g\n", b, a);
+  return a;
+}

casadi/include/casadi/core/serializer.hpp

@@ -77,9 +77,9 @@ namespace casadi {
 
     enum SerializationType {
       SERIALIZED_SPARSITY,
-      SERIALIZED_MX,
+      SERIALIZED_MX_v1,
       SERIALIZED_DM,
-      SERIALIZED_SX,
+      SERIALIZED_SX_v1,
       SERIALIZED_LINSOL,
       SERIALIZED_FUNCTION,
       SERIALIZED_GENERICTYPE,
@@ -87,15 +87,19 @@ namespace casadi {
       SERIALIZED_DOUBLE,
       SERIALIZED_STRING,
       SERIALIZED_SPARSITY_VECTOR,
-      SERIALIZED_MX_VECTOR,
+      SERIALIZED_MX_VECTOR_v1,
       SERIALIZED_DM_VECTOR,
-      SERIALIZED_SX_VECTOR,
+      SERIALIZED_SX_VECTOR_v1,
       SERIALIZED_LINSOL_VECTOR,
       SERIALIZED_FUNCTION_VECTOR,
       SERIALIZED_GENERICTYPE_VECTOR,
       SERIALIZED_INT_VECTOR,
       SERIALIZED_DOUBLE_VECTOR,
       SERIALIZED_STRING_VECTOR,
+      SERIALIZED_MX,
+      SERIALIZED_SX,
+      SERIALIZED_MX_VECTOR,
+      SERIALIZED_SX_VECTOR
     };
 
     static std::string type_to_string(SerializationType type);
@@ -121,8 +125,10 @@ namespace casadi {
 
     Sparsity blind_unpack_sparsity();
     MX blind_unpack_mx();
+    MX blind_unpack_mx_v1();
     Matrix<double> blind_unpack_dm();
     Matrix<SXElem> blind_unpack_sx();
+    Matrix<SXElem> blind_unpack_sx_v1();
     Linsol blind_unpack_linsol();
     Function blind_unpack_function();
     GenericType blind_unpack_generictype();
@@ -131,8 +137,10 @@ namespace casadi {
     std::string blind_unpack_string();
     std::vector<Sparsity> blind_unpack_sparsity_vector();
     std::vector<MX> blind_unpack_mx_vector();
+    std::vector<MX> blind_unpack_mx_vector_v1();
     std::vector< Matrix<double> > blind_unpack_dm_vector();
     std::vector< Matrix<SXElem> > blind_unpack_sx_vector();
+    std::vector< Matrix<SXElem> > blind_unpack_sx_vector_v1();
     std::vector<Linsol> blind_unpack_linsol_vector();
     std::vector<Function> blind_unpack_function_vector();
     std::vector<GenericType> blind_unpack_generictype_vector();

casadi/include/casadi/core/serializing_stream.hpp

@@ -41,6 +41,7 @@ namespace casadi {
   class SXElem;
   class GenericType;
   class Importer;
+  class Resource;
   class Fmu;
   class SharedObject;
   class SharedObjectInternal;
@@ -93,6 +94,7 @@ namespace casadi {
     }
     void unpack(Function& e);
     void unpack(Importer& e);
+    void unpack(Resource& e);
     void unpack(Fmu& e);
     void unpack(GenericType& e);
     void unpack(std::ostream& s);
@@ -231,6 +233,7 @@ namespace casadi {
     }
     void pack(const Function& e);
     void pack(const Importer& e);
+    void pack(const Resource& e);
     void pack(const Fmu& e);
     void pack(const Slice& e);
     void pack(const GenericType& e);

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>;